Initial revision

svn-id: r4785

65 files changed, 36285 insertions, 0 deletions

diff --git a/backends/dc/.cvsignore b/backends/dc/.cvsignore
new file mode 100644
index 0000000000..ed6bd2b99e
--- /dev/null
+++ b/backends/dc/.cvsignore
@@ -0,0 +1,5 @@
+scummvm
+sound
+v3
+v4
+simon
diff --git a/backends/dc/Makefile b/backends/dc/Makefile
new file mode 100644
index 0000000000..18ba20d6fc
--- /dev/null
+++ b/backends/dc/Makefile
@@ -0,0 +1,39 @@
+# $Header$
+
+ronindir = /usr/local/ronin
+
+VPATH = ..
+
+CC      = sh-elf-g++ -ml -m4-single-only
+CFLAGS  = -O1 -Wno-multichar
+DEFINES = -D__DC__ -DNONSTANDARD_PORT -DNONSTANDARD_SAVE
+LDFLAGS := -Wl,-Ttext,0x8c010000 -nostartfiles ronin/crt0.o
+INCLUDES:= -I./ -I../ -I../sound
+CPPFLAGS= $(DEFINES) $(INCLUDES)
+LIBS	= ronin/libronin.a ronin/libz.a -lm
+EXEEXT =
+
+OBJS =	dcmain.o display.o audio.o input.o selector.o icon.o \
+	label.o vmsave.o
+
+include ../Makefile.common
+
+INCS	+= portdefs.h dc.h
+
+$(OBJS): Makefile sound/.create simon/.create v3/.create v4/.create ronin
+
+sound/.create:
+	mkdir sound && touch $@
+
+simon/.create:
+	mkdir simon && touch $@
+
+v3/.create:
+	mkdir v3 && touch $@
+
+v4/.create:
+	mkdir v4 && touch $@
+
+ronin:
+	ln -s $(ronindir) $@
+
diff --git a/backends/dc/README b/backends/dc/README
new file mode 100644
index 0000000000..d4bf04c5bd
--- /dev/null
+++ b/backends/dc/README
@@ -0,0 +1,20 @@
+Compiling ScummVM for SEGA Dreamcast
+====================================
+
+If you want to compile ScummVM for your Dreamcast,
+you'll need the following:
+
+* gcc-3.0.x configured as a cross-compiler for `sh-elf'
+  (including corresponding binutils)
+
+* newlib for sh-elf : <URL:http://mc.pp.se/dc/files/newlib-1.9.0.tar.gz>
+
+* libronin-0.3 : <URL:http://peter.bortas.org/scumm/libronin-0.3.tar.gz>
+
+* GNU make
+
+
+Edit the Makefile to contain the path to libronin if you installed it
+somewhere other than /usr/local/ronin, then run `make', and you should
+get an ELF binary with the name `scummvm'.
+
diff --git a/backends/dc/audio.cpp b/backends/dc/audio.cpp
new file mode 100644
index 0000000000..863c1e97ac
--- /dev/null
+++ b/backends/dc/audio.cpp
@@ -0,0 +1,86 @@
+/* ScummVM - Scumm Interpreter
+ * Dreamcast port
+ * Copyright (C) 2002  Marcus Comstedt
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "scumm.h"
+#include "dc.h"
+
+EXTERN_C void *memcpy4(void *s1, const void *s2, unsigned int n);
+
+void initSound()
+{
+  stop_sound();
+  do_sound_command(CMD_SET_FREQ_EXP(FREQ_22050_EXP));
+  do_sound_command(CMD_SET_BUFFER(3));
+}
+
+bool OSystem_Dreamcast::set_sound_proc(void *param, SoundProc *proc,
+				       byte format)
+{
+#if SAMPLE_MODE == 0
+  assert(format == SOUND_16BIT);
+#elif SAMPLE_MODE == 1
+  assert(format == SOUND_8BIT);
+#else
+#error Invalid SAMPLE_MODE
+#endif
+  _sound_proc_param = param;
+  _sound_proc = proc;
+
+  return true;
+}
+
+void OSystem_Dreamcast::checkSound()
+{
+  int n;
+  int curr_ring_buffer_samples;
+
+  if(read_sound_int(&SOUNDSTATUS->mode) != MODE_PLAY)
+    start_sound();
+
+  curr_ring_buffer_samples = read_sound_int(&SOUNDSTATUS->ring_length);
+
+  n = read_sound_int(&SOUNDSTATUS->samplepos);
+
+  if((n-=fillpos)<0)
+    n += curr_ring_buffer_samples;
+
+  n = ADJUST_BUFFER_SIZE(n-10);
+
+  if(n<100)
+    return;
+
+  _sound_proc(_sound_proc_param, (byte*)temp_sound_buffer,
+	      SAMPLES_TO_BYTES(n));
+
+  if(fillpos+n > curr_ring_buffer_samples) {
+    int r = curr_ring_buffer_samples - fillpos;
+    memcpy4(RING_BUF+fillpos, temp_sound_buffer, SAMPLES_TO_BYTES(r));
+    fillpos = 0;
+    n -= r;
+    memcpy4(RING_BUF, temp_sound_buffer+r, SAMPLES_TO_BYTES(n));
+  } else {
+    memcpy4(RING_BUF+fillpos, temp_sound_buffer, SAMPLES_TO_BYTES(n));
+  }
+  if((fillpos += n) >= curr_ring_buffer_samples)
+    fillpos = 0;
+}
diff --git a/backends/dc/dc.h b/backends/dc/dc.h
new file mode 100644
index 0000000000..4a2b78cfb7
--- /dev/null
+++ b/backends/dc/dc.h
@@ -0,0 +1,102 @@
+#include <ronin/soundcommon.h>
+
+#define NUM_BUFFERS 4
+
+class OSystem_Dreamcast : public OSystem {
+
+ public:
+  // Set colors of the palette
+  void set_palette(const byte *colors, uint start, uint num);
+
+  // Set the size of the video bitmap.
+  // Typically, 320x200
+  void init_size(uint w, uint h);
+
+  // Draw a bitmap to screen.
+  // The screen will not be updated to reflect the new bitmap
+  void copy_rect(const byte *buf, int pitch, int x, int y, int w, int h);
+
+  // Update the dirty areas of the screen
+  void update_screen();
+
+  // Either show or hide the mouse cursor
+  bool show_mouse(bool visible);
+  
+  // Set the position of the mouse cursor
+  void set_mouse_pos(int x, int y);
+  
+  // Set the bitmap that's used when drawing the cursor.
+  void set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y);
+  
+  // Shaking is used in SCUMM. Set current shake position.
+  void set_shake_pos(int shake_pos);
+
+  // Get the number of milliseconds since the program was started.
+  uint32 get_msecs();
+  
+  // Delay for a specified amount of milliseconds
+  void delay_msecs(uint msecs);
+  
+  // Create a thread
+  void *create_thread(ThreadProc *proc, void *param);
+	
+  // Get the next event.
+  // Returns true if an event was retrieved.	
+  bool poll_event(Event *event);
+  
+  // Set function that generates samples 
+  bool set_sound_proc(void *param, SoundProc *proc, byte sound);
+		
+  // Poll cdrom status
+  // Returns true if cd audio is playing
+  bool poll_cdrom();
+
+  // Play cdrom audio track
+  void play_cdrom(int track, int num_loops, int start_frame, int end_frame);
+  
+  // Stop cdrom audio track
+  void stop_cdrom();
+
+  // Update cdrom audio status
+  void update_cdrom();
+
+  // Quit
+  void quit();
+
+  // Set a parameter
+  uint32 property(int param, Property *value);
+
+  static OSystem *create();
+
+
+ private:
+
+  int _ms_cur_x, _ms_cur_y, _ms_cur_w, _ms_cur_h, _ms_old_x, _ms_old_y;
+  int _ms_hotspot_x, _ms_hotspot_y, _ms_visible, _devpoll;
+  int _current_shake_pos, _screen_h;
+  unsigned char *_ms_buf;
+  SoundProc *_sound_proc;
+  void *_sound_proc_param;
+
+  unsigned char *screen;
+  unsigned short *mouse;
+  void *screen_tx[NUM_BUFFERS];
+  void *mouse_tx[NUM_BUFFERS];
+  int current_buffer;
+  unsigned short palette[256];
+
+  short temp_sound_buffer[RING_BUFFER_SAMPLES];
+
+  void checkSound();
+
+  void drawMouse(int xdraw, int ydraw, int w, int h,
+		 unsigned char *buf, bool visible);
+
+};
+
+extern int handleInput(struct mapledev *pad,
+		       int &mouse_x, int &mouse_y,
+		       byte &shiftFlags);
+extern void initSound();
+extern bool selectGame(GameDetector *d, char *&, char *&, class Icon &);
+
diff --git a/backends/dc/dcmain.cpp b/backends/dc/dcmain.cpp
new file mode 100644
index 0000000000..a64643a004
--- /dev/null
+++ b/backends/dc/dcmain.cpp
@@ -0,0 +1,201 @@
+/* ScummVM - Scumm Interpreter
+ * Dreamcast port
+ * Copyright (C) 2002  Marcus Comstedt
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "scumm.h"
+#include "mididrv.h"
+#include "gameDetector.h"
+#include "dc.h"
+#include "icon.h"
+
+
+Icon icon;
+
+
+OSystem *OSystem_Dreamcast_create() {
+	return OSystem_Dreamcast::create();
+}
+
+OSystem *OSystem_Dreamcast::create() {
+	OSystem_Dreamcast *syst = new OSystem_Dreamcast();
+	return syst;
+}
+
+/* CD Audio */
+static bool find_track(int track, int &first_sec, int &last_sec)
+{
+  struct TOC *toc = cdfs_gettoc();
+  if(!toc)
+    return false;
+  int i, first, last;
+  first = TOC_TRACK(toc->first);
+  last = TOC_TRACK(toc->last);
+  if(first < 1 || last > 99 || first > last)
+    return false;
+  for(i=last; i>=first; --i)
+    if(!(TOC_CTRL(toc->entry[i-1])&4))
+      if(track==1) {
+	first_sec = TOC_LBA(toc->entry[i-1]);
+	last_sec = TOC_LBA(toc->entry[i]);
+	return true;
+      } else
+	--track;
+  return false;
+}
+
+void OSystem_Dreamcast::play_cdrom(int track, int num_loops,
+				   int start_frame, int end_frame)
+{
+  int first_sec, last_sec;
+#if 1
+  if(num_loops)
+    --num_loops;
+#endif
+  if(num_loops>14) num_loops=14;
+  else if(num_loops<0) num_loops=15; // infinity
+  if(!find_track(track, first_sec, last_sec))
+    return;
+  if(end_frame)
+    last_sec = first_sec + start_frame + end_frame;
+  first_sec += start_frame;
+  play_cdda_sectors(first_sec, last_sec, num_loops);
+}
+
+void OSystem_Dreamcast::stop_cdrom()
+{
+  stop_cdda();
+}
+
+bool OSystem_Dreamcast::poll_cdrom()
+{
+  extern int getCdState();
+  return getCdState() == 3;
+}
+
+void OSystem_Dreamcast::update_cdrom()
+{
+  // Dummy.  The CD drive takes care of itself.
+}
+
+uint32 OSystem_Dreamcast::property(int param, Property *value)
+{
+  switch(param) {
+
+  case PROP_GET_SAMPLE_RATE:
+    return 22050;
+
+  }
+  
+  return 0;
+}
+
+void OSystem_Dreamcast::quit() {
+  exit(0);
+}
+
+void *OSystem_Dreamcast::create_thread(ThreadProc *proc, void *param) {
+  warning("Creating a thread! (not supported.)\n");
+}
+
+uint32 OSystem_Dreamcast::get_msecs()
+{
+  static uint32 msecs=0;
+  static unsigned int t0=0;
+
+  unsigned int t = Timer();
+  unsigned int dm, dt = t - t0;
+
+  t0 = t;
+  dm = (dt << 6)/3125U;
+  dt -= (dm * 3125U)>>6;
+  t0 -= dt;
+
+  return msecs += dm;
+}
+
+void OSystem_Dreamcast::delay_msecs(uint msecs)
+{
+  get_msecs();
+  unsigned int t, start = Timer();
+  int time = (((unsigned int)msecs)*100000U)>>11;
+  while(((int)((t = Timer())-start))<time)
+    checkSound();
+  get_msecs();
+}
+
+/*
+void waitForTimer(Scumm *s, int time)
+{
+  if(time<0)
+    return;
+  unsigned int start = Timer();
+  unsigned int devpoll = start+USEC_TO_TIMER(25000);
+  unsigned int t;
+  int oldmousex = s->mouse.x, oldmousey = s->mouse.y;
+  time = (((unsigned int)time)*100000U)>>11;
+  int mask = getimask();
+  while(((int)((t = Timer())-start))<time)
+    if(((int)(t-devpoll))>0) {
+      setimask(15);
+      checkSound();
+      handleInput(locked_get_pads(), s->mouse.x, s->mouse.y,
+		  s->_leftBtnPressed, s->_rightBtnPressed, s->_keyPressed);
+      setimask(mask);
+      devpoll += USEC_TO_TIMER(17000);
+      if(s->mouse.x != oldmousex || s->mouse.y != oldmousey) {
+	extern void updateScreen(Scumm *s);
+	updateScreen(s);
+	oldmousex = s->mouse.x;
+	oldmousey = s->mouse.y;
+      }
+    }
+}
+*/
+
+void dc_init_hardware(void)
+{
+#ifndef NOSERIAL
+  serial_init(57600);
+  usleep(2000000);
+  printf("Serial OK\r\n");
+#endif
+
+  cdfs_init();
+  maple_init();
+  dc_setup_ta();
+  init_arm();
+}
+
+int dc_setup(GameDetector &detector)
+{
+  static char *argv[] = { "scummvm", NULL, NULL, NULL };
+  static int argc = 3;
+
+  initSound();
+
+  if(!selectGame(&detector, argv[2], argv[1], icon))
+    exit(0);
+
+  detector.parseCommandLine(argc, argv);
+
+  return 0;
+}
diff --git a/backends/dc/display.cpp b/backends/dc/display.cpp
new file mode 100644
index 0000000000..97c7f2aed5
--- /dev/null
+++ b/backends/dc/display.cpp
@@ -0,0 +1,303 @@
+/* ScummVM - Scumm Interpreter
+ * Dreamcast port
+ * Copyright (C) 2002  Marcus Comstedt
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "scumm.h"
+#include "dc.h"
+
+#define SCREEN_W 320
+#define SCREEN_H 240
+#define MOUSE_W 64
+#define MOUSE_H 64
+
+#define TOP_OFFSET (240.0-_screen_h)
+
+#define QACR0 (*(volatile unsigned int *)(void *)0xff000038)
+#define QACR1 (*(volatile unsigned int *)(void *)0xff00003c)
+
+
+#define COPYPIXEL(n) do {			\
+  unsigned short _tmp = pal[*s++];		\
+  d[n] = _tmp|(pal[*s++]<<16);			\
+} while(0)
+
+static void texture_memcpy64_pal(void *dest, void *src, int cnt, unsigned short *pal)
+{
+  unsigned char *s = (unsigned char *)src;
+  unsigned int *d = (unsigned int *)(void *)
+    (0xe0000000 | (((unsigned long)dest) & 0x03ffffc0));
+  QACR0 = ((0xa4000000>>26)<<2)&0x1c;
+  QACR1 = ((0xa4000000>>26)<<2)&0x1c;
+  while(cnt--) {
+    COPYPIXEL(0);
+    COPYPIXEL(1);
+    COPYPIXEL(2);
+    COPYPIXEL(3);
+    asm("pref @%0" : : "r" (s+4*16));
+    COPYPIXEL(4);
+    COPYPIXEL(5);
+    COPYPIXEL(6);
+    COPYPIXEL(7);
+    asm("pref @%0" : : "r" (d));
+    d += 8;
+    COPYPIXEL(0);
+    COPYPIXEL(1);
+    COPYPIXEL(2);
+    COPYPIXEL(3);
+    asm("pref @%0" : : "r" (s+4*16));
+    COPYPIXEL(4);
+    COPYPIXEL(5);
+    COPYPIXEL(6);
+    COPYPIXEL(7);
+    asm("pref @%0" : : "r" (d));
+    d += 8;
+  }
+}
+
+void commit_dummy_transpoly()
+{
+  struct polygon_list mypoly;
+
+  mypoly.cmd =
+    TA_CMD_POLYGON|TA_CMD_POLYGON_TYPE_TRANSPARENT|TA_CMD_POLYGON_SUBLIST|
+    TA_CMD_POLYGON_STRIPLENGTH_2|TA_CMD_POLYGON_PACKED_COLOUR;
+  mypoly.mode1 = TA_POLYMODE1_Z_ALWAYS|TA_POLYMODE1_NO_Z_UPDATE;
+  mypoly.mode2 =
+    TA_POLYMODE2_BLEND_SRC_ALPHA|TA_POLYMODE2_BLEND_DST_INVALPHA|
+    TA_POLYMODE2_FOG_DISABLED|TA_POLYMODE2_ENABLE_ALPHA;
+  mypoly.texture = 0;
+  mypoly.red = mypoly.green = mypoly.blue = mypoly.alpha = 0;
+  ta_commit_list(&mypoly);
+}
+
+
+void OSystem_Dreamcast::set_palette(const byte *colors, uint start, uint num)
+{
+  unsigned short *dst = palette + start;
+  if(num>0)
+    while( num-- ) {
+      *dst++ = ((colors[0]<<7)&0x7c00)|
+	((colors[1]<<2)&0x03e0)|
+	((colors[2]>>3)&0x001f);
+      colors += 4;
+    }
+}
+
+void OSystem_Dreamcast::init_size(uint w, uint h)
+{
+  assert(w == SCREEN_W && h <= SCREEN_H);
+
+  _screen_h = h;
+  ta_sync();
+  if(!screen)
+    screen = new unsigned char[SCREEN_W*SCREEN_H];
+  for(int i=0; i<NUM_BUFFERS; i++)
+    if(!screen_tx[i])
+      screen_tx[i] = ta_txalloc(SCREEN_W*SCREEN_H*2);
+  for(int i=0; i<NUM_BUFFERS; i++)
+    if(!mouse_tx[i])
+      mouse_tx[i] = ta_txalloc(MOUSE_W*MOUSE_H*2);
+  current_buffer = 0;
+  *(volatile unsigned int *)(0xa05f80e4) = SCREEN_W/32; //stride
+  //  dc_reset_screen(0, 0);
+}
+
+void OSystem_Dreamcast::copy_rect(const byte *buf, int pitch, int x, int y,
+				  int w, int h)
+{
+  unsigned char *dst = screen + y*SCREEN_W + x;
+  do {
+    memcpy(dst, buf, w);
+    dst += SCREEN_W;
+    buf += pitch;
+  } while (--h);
+}
+
+bool OSystem_Dreamcast::show_mouse(bool visible)
+{	
+  bool last = _ms_visible;
+  _ms_visible = visible;
+
+  return last;
+}
+
+void OSystem_Dreamcast::set_mouse_pos(int x, int y)
+{
+  _ms_cur_x = x;
+  _ms_cur_y = y;
+}
+
+void OSystem_Dreamcast::set_mouse_cursor(const byte *buf, uint w, uint h,
+					 int hotspot_x, int hotspot_y)
+{
+  _ms_cur_w = w;
+  _ms_cur_h = h;
+  
+  _ms_hotspot_x = hotspot_x;
+  _ms_hotspot_y = hotspot_y;
+  
+  _ms_buf = (byte*)buf;
+}
+
+void OSystem_Dreamcast::set_shake_pos(int shake_pos)
+{
+  _current_shake_pos = shake_pos;
+}
+
+void OSystem_Dreamcast::update_screen(void)
+{
+  struct polygon_list mypoly;
+  struct packed_colour_vertex_list myvertex;
+
+  unsigned short *dst = (unsigned short *)screen_tx[current_buffer];
+  unsigned char *src = screen;
+
+  // while((*((volatile unsigned int *)(void*)0xa05f810c) & 0x3ff) != 200);
+  // *((volatile unsigned int *)(void*)0xa05f8040) = 0xff0000;
+  
+  for( int y = 0; y<_screen_h; y++ )
+  {
+    texture_memcpy64_pal( dst, src, SCREEN_W>>5, palette );
+    src += SCREEN_W;
+    dst += SCREEN_W;
+  }
+
+  // *((volatile unsigned int *)(void*)0xa05f8040) = 0x00ff00;
+
+  mypoly.cmd =
+    TA_CMD_POLYGON|TA_CMD_POLYGON_TYPE_OPAQUE|TA_CMD_POLYGON_SUBLIST|
+    TA_CMD_POLYGON_STRIPLENGTH_2|TA_CMD_POLYGON_PACKED_COLOUR|TA_CMD_POLYGON_TEXTURED;
+  mypoly.mode1 = TA_POLYMODE1_Z_ALWAYS|TA_POLYMODE1_NO_Z_UPDATE;
+  mypoly.mode2 =
+    TA_POLYMODE2_BLEND_SRC|TA_POLYMODE2_FOG_DISABLED|TA_POLYMODE2_TEXTURE_REPLACE|
+    TA_POLYMODE2_U_SIZE_512|TA_POLYMODE2_V_SIZE_512;
+  mypoly.texture = TA_TEXTUREMODE_ARGB1555|TA_TEXTUREMODE_NON_TWIDDLED|
+    TA_TEXTUREMODE_STRIDE|TA_TEXTUREMODE_ADDRESS(screen_tx[current_buffer]);
+
+  mypoly.red = mypoly.green = mypoly.blue = mypoly.alpha = 0;
+  
+  ta_begin_frame();
+  // *((volatile unsigned int *)(void*)0xa05f8040) = 0x0000ff;
+  ta_commit_list(&mypoly);
+  
+  myvertex.cmd = TA_CMD_VERTEX;
+  myvertex.ocolour = 0;
+  myvertex.colour = 0;
+  myvertex.z = 0.5;
+  myvertex.u = 0.0;
+  myvertex.v = 0.0;
+
+  myvertex.x = 0.0;
+  myvertex.y = _current_shake_pos*2.0+TOP_OFFSET;
+  ta_commit_list(&myvertex);
+
+  myvertex.x = SCREEN_W*2.0;
+  myvertex.u = SCREEN_W/512.0;
+  ta_commit_list(&myvertex);
+
+  myvertex.x = 0.0;
+  myvertex.y += _screen_h*2.0;
+  myvertex.u = 0.0;
+  myvertex.v = _screen_h*(1/512.0);
+  ta_commit_list(&myvertex);
+
+  myvertex.x = SCREEN_W*2.0;
+  myvertex.u = SCREEN_W/512.0;
+  myvertex.cmd |= TA_CMD_VERTEX_EOS;
+  ta_commit_list(&myvertex);
+
+  ta_commit_end();
+  // *((volatile unsigned int *)(void*)0xa05f8040) = 0xffff00;
+  drawMouse(_ms_cur_x, _ms_cur_y, _ms_cur_w, _ms_cur_h, _ms_buf, _ms_visible);
+  // *((volatile unsigned int *)(void*)0xa05f8040) = 0xff00ff;
+  ta_commit_frame();
+
+  current_buffer++;
+  current_buffer &= NUM_BUFFERS-1;
+  // *((volatile unsigned int *)(void*)0xa05f8040) = 0x0;
+}
+
+void OSystem_Dreamcast::drawMouse(int xdraw, int ydraw, int w, int h,
+				  unsigned char *buf, bool visible)
+{
+  struct polygon_list mypoly;
+  struct packed_colour_vertex_list myvertex;
+
+  unsigned short *dst = (unsigned short *)mouse_tx[current_buffer];
+  int y=0;
+
+  if(visible && w<=MOUSE_W && h<=MOUSE_H)
+    for(int y=0; y<h; y++) {
+      int x;
+      for(x=0; x<w; x++)
+	if(*buf == 0xff) {
+	  *dst++ = 0;
+	  buf++;
+	} else
+	  *dst++ = palette[*buf++]|0x8000;
+      dst += MOUSE_W-x;
+    }
+  else
+    w = h = 0;
+  
+  mypoly.cmd =
+    TA_CMD_POLYGON|TA_CMD_POLYGON_TYPE_TRANSPARENT|TA_CMD_POLYGON_SUBLIST|
+    TA_CMD_POLYGON_STRIPLENGTH_2|TA_CMD_POLYGON_PACKED_COLOUR|TA_CMD_POLYGON_TEXTURED;
+  mypoly.mode1 = TA_POLYMODE1_Z_ALWAYS|TA_POLYMODE1_NO_Z_UPDATE;
+  mypoly.mode2 =
+    TA_POLYMODE2_BLEND_SRC_ALPHA|TA_POLYMODE2_BLEND_DST_INVALPHA|
+    TA_POLYMODE2_FOG_DISABLED|TA_POLYMODE2_TEXTURE_REPLACE|
+    TA_POLYMODE2_U_SIZE_64|TA_POLYMODE2_V_SIZE_64;
+  mypoly.texture = TA_TEXTUREMODE_ARGB1555|TA_TEXTUREMODE_NON_TWIDDLED|
+    TA_TEXTUREMODE_ADDRESS(mouse_tx[current_buffer]);
+
+  mypoly.red = mypoly.green = mypoly.blue = mypoly.alpha = 0;
+  
+  ta_commit_list(&mypoly);
+  
+  myvertex.cmd = TA_CMD_VERTEX;
+  myvertex.ocolour = 0;
+  myvertex.colour = 0xffff00;
+  myvertex.z = 0.25;
+  myvertex.u = 0.0;
+  myvertex.v = 0.0;
+
+  myvertex.x = (xdraw-_ms_hotspot_y)*2.0;
+  myvertex.y = (ydraw+_current_shake_pos-_ms_hotspot_x)*2.0 + TOP_OFFSET;
+  ta_commit_list(&myvertex);
+
+  myvertex.x += w*2.0;
+  myvertex.u = w*(1.0/MOUSE_W);
+  ta_commit_list(&myvertex);
+
+  myvertex.x = (xdraw-_ms_hotspot_y)*2.0;
+  myvertex.y += h*2.0;
+  myvertex.u = 0.0;
+  myvertex.v = h*(1.0/MOUSE_H);
+  ta_commit_list(&myvertex);
+
+  myvertex.x += w*2.0;
+  myvertex.u = w*(1.0/MOUSE_W);
+  myvertex.cmd |= TA_CMD_VERTEX_EOS;
+  ta_commit_list(&myvertex);
+}
+
diff --git a/backends/dc/icon.cpp b/backends/dc/icon.cpp
new file mode 100644
index 0000000000..93e70ad2b5
--- /dev/null
+++ b/backends/dc/icon.cpp
@@ -0,0 +1,228 @@
+/* ScummVM - Scumm Interpreter
+ * Dreamcast port
+ * Copyright (C) 2002  Marcus Comstedt
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include <ronin/ronin.h>
+#include <string.h>
+
+#include "icon.h"
+
+void Icon::create_vmicon(void *buffer)
+{
+  unsigned short *pal = (unsigned short *)buffer;
+  unsigned char *pix = ((unsigned char *)buffer)+32;
+
+  for(int n = 0; n<16; n++) {
+    int p = palette[n];
+    pal[n] = 
+      ((p>>16)&0xf000)|
+      ((p>>12)&0x0f00)|
+      ((p>> 8)&0x00f0)|
+      ((p>> 4)&0x000f);
+  }
+
+  for(int line = 0; line < 32; line++) {
+    memcpy(pix, &bitmap[32/2*(31-line)], 32/2);
+    pix += 32/2;
+  }
+}
+
+void Icon::create_texture()
+{
+  static char tt[16] = { 0, 1, 4, 5, 16, 17, 20, 21,
+			 64, 65, 68, 69, 80, 81, 84, 85 };
+  unsigned short *tex = (unsigned short *)ta_txalloc(512);
+  unsigned short *linebase;
+  unsigned char *src = bitmap+sizeof(bitmap)-17;
+  for(int y=0; y<16; y++) {
+    linebase = tex + (tt[y]<<1);
+    for(int x=0; x<16; x++, --src)
+      linebase[tt[x]] = src[16]|(src[0]<<8);
+    src -= 16;
+  }
+  texture = tex;
+}
+
+void Icon::set_palette(int pal)
+{
+  unsigned int (*hwpal)[64][16] = (unsigned int (*)[64][16])0xa05f9000;
+  for(int n = 0; n<16; n++)
+    (*hwpal)[pal][n] = palette[n];
+}
+
+void Icon::draw(float x1, float y1, float x2, float y2, int pal,
+		unsigned int argb)
+{
+  struct polygon_list mypoly;
+  struct packed_colour_vertex_list myvertex;
+
+  mypoly.cmd =
+    TA_CMD_POLYGON|TA_CMD_POLYGON_TYPE_TRANSPARENT|TA_CMD_POLYGON_SUBLIST|
+    TA_CMD_POLYGON_STRIPLENGTH_2|TA_CMD_POLYGON_PACKED_COLOUR|TA_CMD_POLYGON_TEXTURED;
+  mypoly.mode1 = TA_POLYMODE1_Z_ALWAYS|TA_POLYMODE1_NO_Z_UPDATE;
+  mypoly.mode2 =
+    TA_POLYMODE2_BLEND_SRC_ALPHA|TA_POLYMODE2_BLEND_DST_INVALPHA|
+    TA_POLYMODE2_FOG_DISABLED|TA_POLYMODE2_ENABLE_ALPHA|
+    TA_POLYMODE2_TEXTURE_MODULATE_ALPHA|TA_POLYMODE2_U_SIZE_32|
+    TA_POLYMODE2_V_SIZE_32;
+  mypoly.texture = TA_TEXTUREMODE_CLUT4|TA_TEXTUREMODE_CLUTBANK4(pal)|
+    TA_TEXTUREMODE_ADDRESS(texture);
+
+  mypoly.red = mypoly.green = mypoly.blue = mypoly.alpha = 0;
+
+  ta_commit_list(&mypoly);
+
+  myvertex.cmd = TA_CMD_VERTEX;
+  myvertex.ocolour = 0;
+  myvertex.colour = argb;
+  myvertex.z = 0.5;
+  myvertex.u = 0.0;
+  myvertex.v = 1.0;
+
+  myvertex.x = x1;
+  myvertex.y = y1;
+  ta_commit_list(&myvertex);
+
+  myvertex.x = x2;
+  myvertex.v = 0.0;
+  ta_commit_list(&myvertex);
+
+  myvertex.x = x1;
+  myvertex.y = y2;
+  myvertex.u = 1.0;
+  myvertex.v = 1.0;
+  ta_commit_list(&myvertex);
+
+  myvertex.x = x2;
+  myvertex.v = 0.0;
+  myvertex.cmd |= TA_CMD_VERTEX_EOS;
+  ta_commit_list(&myvertex);  
+}
+
+int Icon::find_unused_pixel()
+{
+  int use[16];
+  memset(use, 0, sizeof(use));
+  for(int n=0; n<32*32/2; n++) {
+    unsigned char pix = bitmap[n];
+    use[pix&0xf]++;
+    use[pix>>4]++;
+  }
+  for(int i=0; i<16; i++)
+    if(!use[i])
+      return i;
+  return -1;
+}
+
+bool Icon::load_image2(void *data, int len)
+{
+  struct {
+    int size, w, h;
+    short pla, bitcnt;
+    int comp, sizeimg, xres, yres, used, imp;
+  } hdr;
+  if(len < 40)
+    return false;
+  memcpy(&hdr, data, 40);
+  if(hdr.size != 40 || hdr.sizeimg<=0 || hdr.w<0 || hdr.h<0 ||
+     hdr.bitcnt<0 || hdr.used<0)
+    return false;
+  if(!hdr.used)
+    hdr.used = 1<<hdr.bitcnt;
+  hdr.h >>= 1;
+  if(hdr.size + (hdr.used<<2) + hdr.sizeimg > len ||
+     hdr.sizeimg < ((hdr.w*hdr.h*(1+hdr.bitcnt)+7)>>3))
+    return false;
+  if(hdr.w != 32 || hdr.h != 32 || hdr.bitcnt != 4 || hdr.used > 16)
+    return false;
+  memcpy(palette, ((char *)data)+hdr.size, hdr.used<<2);
+  memcpy(bitmap, ((char *)data)+hdr.size+(hdr.used<<2), 32*32/2);
+  for(int i=0; i<16; i++)
+    palette[i] |= 0xff000000;
+  for(int i=hdr.used; i<16; i++)
+    palette[i] = 0;
+  int unused = find_unused_pixel();
+  if(unused >= 0) {
+    unsigned char *mask =
+      ((unsigned char *)data)+hdr.size+(hdr.used<<2)+32*32/2;
+    unsigned char *pix = bitmap;
+    for(int y=0; y<32; y++)
+      for(int x=0; x<32/8; x++) {
+	unsigned char mbits = *mask++;
+	for(int z=0; z<4; z++) {
+	  unsigned char pbits = *pix;
+	  if(mbits & 64) pbits = (pbits & ~0xf) | unused;
+	  if(mbits & 128) pbits = (pbits & 0xf) | (unused << 4);
+	  *pix++ = pbits;
+	  mbits <<= 2;
+	}
+      }
+    palette[unused] = 0;
+  }
+  return true;
+}
+
+bool Icon::load_image1(void *data, int len, int offs)
+{
+  struct {
+    char w, h, colors, rsrv;
+    short pla, bitcnt;
+    int bytes, offs;
+  } hdr;
+  if(len < offs+16)
+    return false;
+  memcpy(&hdr, ((char *)data)+offs, 16);
+  if(hdr.bytes > 0 && hdr.offs >= 0 && hdr.offs+hdr.bytes <= len)
+    return load_image2(((char *)data)+hdr.offs, hdr.bytes);
+  else
+    return false;
+}
+
+bool Icon::load(void *data, int len, int offs)
+{
+  struct { short rsrv, type, cnt; } hdr;
+  memset(bitmap, 0, sizeof(bitmap));
+  memset(palette, 0, sizeof(palette));
+  texture = NULL;
+  if(len < offs+6)
+    return false;
+  memcpy(&hdr, ((char *)data)+offs, 6);
+  if(hdr.type != 1 || hdr.cnt < 1 || offs+6+(hdr.cnt<<4) > len)
+    return false;
+  for(int i=0; i<hdr.cnt; i++)
+    if(load_image1(data, len, offs+6+(i<<4)))
+      return true;
+  return false;
+}
+
+bool Icon::load(const char *filename)
+{
+  char buf[2048];
+  int fd;
+  if((fd = open(filename, O_RDONLY))>=0) {
+    int sz;
+    sz = read(fd, buf, sizeof(buf));
+    close(fd);
+    if(sz>0)
+      return load(buf, sz);
+  }
+  return false;
+}
diff --git a/backends/dc/icon.h b/backends/dc/icon.h
new file mode 100644
index 0000000000..b9cf344bab
--- /dev/null
+++ b/backends/dc/icon.h
@@ -0,0 +1,21 @@
+
+class Icon
+{
+ private:
+  unsigned char bitmap[32*32/2];
+  unsigned int palette[16];
+  void *texture;
+
+  int find_unused_pixel();
+  bool load_image1(void *data, int len, int offs);
+  bool load_image2(void *data, int len);
+
+ public:
+  bool load(void *data, int len, int offs = 0);
+  bool load(const char *filename);
+  void create_texture();
+  void set_palette(int pal);
+  void draw(float x1, float y1, float x2, float y2, int pal,
+	    unsigned argb = 0xffffffff);
+  void create_vmicon(void *buffer);
+};
diff --git a/backends/dc/input.cpp b/backends/dc/input.cpp
new file mode 100644
index 0000000000..ed7289e463
--- /dev/null
+++ b/backends/dc/input.cpp
@@ -0,0 +1,173 @@
+/* ScummVM - Scumm Interpreter
+ * Dreamcast port
+ * Copyright (C) 2002  Marcus Comstedt
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "scumm.h"
+#include "dc.h"
+
+int handleInput(struct mapledev *pad, int &mouse_x, int &mouse_y,
+		byte &shiftFlags)
+{
+  int lmb=0, rmb=0, newkey=0;
+  static int lastkey = 0;
+  static byte lastlmb = 0, lastrmb = 0;
+  shiftFlags = 0;
+  for(int i=0; i<4; i++, pad++)
+    if(pad->func & MAPLE_FUNC_CONTROLLER) {
+      int buttons = pad->cond.controller.buttons;
+
+      if(!(buttons & 0x060e)) exit(0);
+
+      if(!(buttons & 4)) lmb++;
+      if(!(buttons & 2)) rmb++;
+
+      if(!(buttons & 8)) newkey = 319;
+      else if(!(buttons & 512)) newkey = ' ';
+      else if(!(buttons & 1024)) newkey = '0';
+
+      if(!(buttons & 128)) mouse_x++;
+      if(!(buttons & 64)) mouse_x--;
+      if(!(buttons & 32)) mouse_y++;
+      if(!(buttons & 16)) mouse_y--;
+
+      mouse_x += ((int)pad->cond.controller.joyx-128)>>4;
+      mouse_y += ((int)pad->cond.controller.joyy-128)>>4;
+    } else if(pad->func & MAPLE_FUNC_MOUSE) {
+      int buttons = pad->cond.mouse.buttons;
+
+      if(!(buttons & 4)) lmb++;
+      if(!(buttons & 2)) rmb++;
+
+      if(!(buttons & 8)) newkey = 319;
+      
+      mouse_x += pad->cond.mouse.axis1;
+      mouse_y += pad->cond.mouse.axis2;
+      pad->cond.mouse.axis1 = 0;
+      pad->cond.mouse.axis2 = 0;
+    } else if(pad->func & MAPLE_FUNC_KEYBOARD) {
+      for(int p=0; p<6; p++) {
+	int shift = pad->cond.kbd.shift;
+	int key = pad->cond.kbd.key[p];
+	if(shift & 0x08) lmb++;
+	if(shift & 0x80) rmb++;
+	if(shift & 0x11) shiftFlags |= OSystem::KBD_CTRL;
+	if(shift & 0x44) shiftFlags |= OSystem::KBD_ALT;
+	if(shift & 0x22) shiftFlags |= OSystem::KBD_SHIFT;
+	if(key >= 4 && key <= 0x1d)
+	  newkey = key+('a'-4);
+	else if(key >= 0x1e && key <= 0x26)
+	  newkey = key+((shift & 0x22)? ('!'-0x1e) : ('1'-0x1e));
+	else if(key >= 0x59 && key <= 0x61)
+	  newkey = key+('1'-0x59);
+	else if(key >= 0x3a && key <= 0x43)
+	  newkey = key+(315-0x3a);
+	else switch(key) {
+	case 0x27: case 0x62:
+	  newkey = ((shift & 0x22)? '~' : '0'); break;
+	case 0x28: case 0x58:
+	  newkey = 13; break;
+	case 0x29:
+	  newkey = 27; break;
+	case 0x2a:
+	  newkey = 8; break;
+	case 0x2b:
+	  newkey = 9; break;
+	case 0x2c:
+	  newkey = ' '; break;
+	case 0x4c:
+	  if((shift & 0x11) && (shift & 0x44))
+	    exit(0);
+	  break;
+	case 0x4f:
+	  mouse_x++; break;
+	case 0x50:
+	  mouse_x--; break;
+	case 0x51:
+	  mouse_y++; break;
+	case 0x52:
+	  mouse_y--; break;
+	}
+      }
+    }
+
+  if(lmb && !lastlmb) {
+    lastlmb = 1;
+    return -OSystem::EVENT_LBUTTONDOWN;
+  } else if(lastlmb && !lmb) {
+    lastlmb = 0;
+    return -OSystem::EVENT_LBUTTONUP;
+  }
+  if(rmb && !lastrmb) {
+    lastrmb = 1;
+    return -OSystem::EVENT_RBUTTONDOWN;
+  } else if(lastrmb && !rmb) {
+    lastrmb = 0;
+    return -OSystem::EVENT_RBUTTONUP;
+  }
+
+  if(!newkey)
+    lastkey = 0;
+  else if(newkey != lastkey)
+    return lastkey = newkey;
+
+  return 0;
+}
+
+bool OSystem_Dreamcast::poll_event(Event *event)
+{
+  unsigned int t = Timer();
+  if(((int)(t-_devpoll))<0)
+    return false;
+  _devpoll += USEC_TO_TIMER(17000);
+  int mask = getimask();
+  setimask(15);
+  checkSound();
+  int e = handleInput(locked_get_pads(), _ms_cur_x, _ms_cur_y,
+		      event->kbd.flags);
+  setimask(mask);
+  if (_ms_cur_x<0) _ms_cur_x=0;
+  if (_ms_cur_x>319) _ms_cur_x=319;
+  if (_ms_cur_y<0) _ms_cur_y=0;
+  if (_ms_cur_y>=_screen_h) _ms_cur_y=_screen_h-1;
+  event->mouse.x = _ms_cur_x;
+  event->mouse.y = _ms_cur_y;
+  event->kbd.ascii = event->kbd.keycode = 0;
+  if(e<0) {
+    event->event_code = -e;
+    return true;
+  } else if(e>0) {
+    event->event_code = EVENT_KEYDOWN;
+    event->kbd.keycode = e;
+    event->kbd.ascii = (e>='a' && e<='z' && (event->kbd.flags & KBD_SHIFT)?
+			e &~ 0x20 : e);
+    return true;
+  } else if(_ms_cur_x != _ms_old_x || _ms_cur_y != _ms_old_y) {
+    event->event_code = EVENT_MOUSEMOVE;
+    _ms_old_x = _ms_cur_x;
+    _ms_old_y = _ms_cur_y;
+    return true;
+  } else {
+    event->event_code = 0;
+    return false;
+  }
+}
+
diff --git a/backends/dc/label.cpp b/backends/dc/label.cpp
new file mode 100644
index 0000000000..8f263eec0a
--- /dev/null
+++ b/backends/dc/label.cpp
@@ -0,0 +1,131 @@
+/* ScummVM - Scumm Interpreter
+ * Dreamcast port
+ * Copyright (C) 2002  Marcus Comstedt
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include <ronin/ronin.h>
+#include <string.h>
+
+#include "label.h"
+
+static void *get_romfont_address()
+{
+  void *ret;
+  __asm__("jsr @%1; mov #0,r1; mov r0,%0" :
+	  "=r" (ret) : "r" (*(void **)0x8c0000b4) :
+	  "pr", "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7");
+  return ret;
+}
+
+static void draw_char(unsigned short *dst, int mod, int c, void *font_base)
+{
+  unsigned char *src;
+  int i, j;
+  if(c<=32 || c>255 || (c>=127 && c<160)) c=160;
+  if(c<128) c -= 32; else c -= 64;
+  src = c*36 + (unsigned char *)font_base;
+  for(i=0; i<12; i++) {
+    int n = (src[0]<<16)|(src[1]<<8)|src[2];
+    for(j=0; j<12; j++, n<<=1)
+      if(n & (1<<23)) {
+	dst[j] = 0xffff;
+	dst[j+1] = 0xffff;
+	dst[j+2] = 0xa108;
+	dst[j+mod] = 0xa108;
+	dst[j+mod+1] = 0xa108;
+      }
+    dst += mod;
+    for(j=0; j<12; j++, n<<=1)
+      if(n & (1<<23)) {
+	dst[j] = 0xffff;
+	dst[j+1] = 0xffff;
+	dst[j+2] = 0xa108;
+	dst[j+mod] = 0xa108;
+	dst[j+mod+1] = 0xa108;
+      }
+    dst += mod;
+    src += 3;
+  }
+}
+
+void Label::create_texture(const char *text)
+{
+  void *font = get_romfont_address();
+  int l = strlen(text);
+  if(l>64) l=64;
+  int w = 14*l;
+  for(tex_u=TA_POLYMODE2_U_SIZE_8, u=8; u<w; u<<=1, tex_u += 1<<3);
+  int tsz = u*32;
+  unsigned short *tex = (unsigned short *)ta_txalloc(tsz*2);
+  for(int i=0; i<tsz; i++)
+    tex[i] = 0;
+  int p=l*14;
+  while(l>0)
+    draw_char(tex+(p-=14), u, text[--l], font);
+  texture = tex;
+}
+
+void Label::draw(float x, float y, unsigned int argb, float scale)
+{
+  struct polygon_list mypoly;
+  struct packed_colour_vertex_list myvertex;
+
+  mypoly.cmd =
+    TA_CMD_POLYGON|TA_CMD_POLYGON_TYPE_TRANSPARENT|TA_CMD_POLYGON_SUBLIST|
+    TA_CMD_POLYGON_STRIPLENGTH_2|TA_CMD_POLYGON_PACKED_COLOUR|TA_CMD_POLYGON_TEXTURED;
+  mypoly.mode1 = TA_POLYMODE1_Z_ALWAYS|TA_POLYMODE1_NO_Z_UPDATE;
+  mypoly.mode2 =
+    TA_POLYMODE2_BLEND_SRC_ALPHA|TA_POLYMODE2_BLEND_DST_INVALPHA|
+    TA_POLYMODE2_FOG_DISABLED|TA_POLYMODE2_ENABLE_ALPHA|
+    TA_POLYMODE2_TEXTURE_MODULATE_ALPHA|TA_POLYMODE2_V_SIZE_32|tex_u;
+  mypoly.texture = TA_TEXTUREMODE_ARGB1555|TA_TEXTUREMODE_NON_TWIDDLED|
+    TA_TEXTUREMODE_ADDRESS(texture);
+
+  mypoly.red = mypoly.green = mypoly.blue = mypoly.alpha = 0;
+
+  ta_commit_list(&mypoly);
+
+  myvertex.cmd = TA_CMD_VERTEX;
+  myvertex.ocolour = 0;
+  myvertex.colour = argb;
+  myvertex.z = 0.5;
+  myvertex.u = 0.0;
+  myvertex.v = 0.0;
+
+  myvertex.x = x;
+  myvertex.y = y;
+  ta_commit_list(&myvertex);
+
+  myvertex.x = x+u*scale;
+  myvertex.u = 1.0;
+  ta_commit_list(&myvertex);
+
+  myvertex.x = x;
+  myvertex.y = y+25.0*scale;
+  myvertex.u = 0.0;
+  myvertex.v = 25.0/32.0;
+  ta_commit_list(&myvertex);
+
+  myvertex.x = x+u*scale;
+  myvertex.u = 1.0;
+  myvertex.cmd |= TA_CMD_VERTEX_EOS;
+  ta_commit_list(&myvertex);  
+}
+
diff --git a/backends/dc/label.h b/backends/dc/label.h
new file mode 100644
index 0000000000..d4a407307d
--- /dev/null
+++ b/backends/dc/label.h
@@ -0,0 +1,11 @@
+class Label
+{
+ private:
+  void *texture;
+  int tex_u, u;
+
+ public:
+  void create_texture(const char *text);
+  void draw(float x, float y, unsigned int argb = 0xffffffff,
+	    float scale = 1.0);
+};
diff --git a/backends/dc/portdefs.h b/backends/dc/portdefs.h
new file mode 100644
index 0000000000..fd7929ffe7
--- /dev/null
+++ b/backends/dc/portdefs.h
@@ -0,0 +1,9 @@
+#include <sys/types.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <ctype.h>
+#include <ronin/ronin.h>
diff --git a/backends/dc/selector.cpp b/backends/dc/selector.cpp
new file mode 100644
index 0000000000..22cba5bbfc
--- /dev/null
+++ b/backends/dc/selector.cpp
@@ -0,0 +1,487 @@
+/* ScummVM - Scumm Interpreter
+ * Dreamcast port
+ * Copyright (C) 2002  Marcus Comstedt
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "scumm.h"
+#include "mididrv.h"
+#include "gameDetector.h"
+#include "dc.h"
+#include "icon.h"
+#include "label.h"
+
+#include <ronin/gddrive.h>
+
+
+#define MAX_GAMES 100
+#define MAX_DIR 100
+
+
+void draw_solid_quad(float x1, float y1, float x2, float y2,
+		     int c0, int c1, int c2, int c3)
+{
+  struct polygon_list mypoly;
+  struct packed_colour_vertex_list myvertex;
+
+  mypoly.cmd =
+    TA_CMD_POLYGON|TA_CMD_POLYGON_TYPE_OPAQUE|TA_CMD_POLYGON_SUBLIST|
+    TA_CMD_POLYGON_STRIPLENGTH_2|TA_CMD_POLYGON_PACKED_COLOUR|
+    TA_CMD_POLYGON_GOURAUD_SHADING;
+  mypoly.mode1 = TA_POLYMODE1_Z_ALWAYS|TA_POLYMODE1_NO_Z_UPDATE;
+  mypoly.mode2 =
+    TA_POLYMODE2_BLEND_SRC|TA_POLYMODE2_FOG_DISABLED;
+  mypoly.texture = 0;
+
+  mypoly.red = mypoly.green = mypoly.blue = mypoly.alpha = 0;
+
+  ta_commit_list(&mypoly);
+
+  myvertex.cmd = TA_CMD_VERTEX;
+  myvertex.ocolour = 0;
+  myvertex.z = 0.5;
+  myvertex.u = 0.0;
+  myvertex.v = 0.0;
+
+  myvertex.colour = c0;
+  myvertex.x = x1;
+  myvertex.y = y1;
+  ta_commit_list(&myvertex);
+
+  myvertex.colour = c1;
+  myvertex.x = x2;
+  ta_commit_list(&myvertex);
+
+  myvertex.colour = c2;
+  myvertex.x = x1;
+  myvertex.y = y2;
+  ta_commit_list(&myvertex);
+
+  myvertex.colour = c3;
+  myvertex.x = x2;
+  myvertex.cmd |= TA_CMD_VERTEX_EOS;
+  ta_commit_list(&myvertex);  
+}
+
+void draw_trans_quad(float x1, float y1, float x2, float y2,
+		     int c0, int c1, int c2, int c3)
+{
+  struct polygon_list mypoly;
+  struct packed_colour_vertex_list myvertex;
+
+  mypoly.cmd =
+    TA_CMD_POLYGON|TA_CMD_POLYGON_TYPE_TRANSPARENT|TA_CMD_POLYGON_SUBLIST|
+    TA_CMD_POLYGON_STRIPLENGTH_2|TA_CMD_POLYGON_PACKED_COLOUR|
+    TA_CMD_POLYGON_GOURAUD_SHADING;
+  mypoly.mode1 = TA_POLYMODE1_Z_ALWAYS|TA_POLYMODE1_NO_Z_UPDATE;
+  mypoly.mode2 =
+    TA_POLYMODE2_BLEND_SRC_ALPHA|TA_POLYMODE2_BLEND_DST_INVALPHA|
+    TA_POLYMODE2_FOG_DISABLED|TA_POLYMODE2_ENABLE_ALPHA;
+  mypoly.texture = 0;
+
+  mypoly.red = mypoly.green = mypoly.blue = mypoly.alpha = 0;
+
+  ta_commit_list(&mypoly);
+
+  myvertex.cmd = TA_CMD_VERTEX;
+  myvertex.ocolour = 0;
+  myvertex.z = 0.5;
+  myvertex.u = 0.0;
+  myvertex.v = 0.0;
+
+  myvertex.colour = c0;
+  myvertex.x = x1;
+  myvertex.y = y1;
+  ta_commit_list(&myvertex);
+
+  myvertex.colour = c1;
+  myvertex.x = x2;
+  ta_commit_list(&myvertex);
+
+  myvertex.colour = c2;
+  myvertex.x = x1;
+  myvertex.y = y2;
+  ta_commit_list(&myvertex);
+
+  myvertex.colour = c3;
+  myvertex.x = x2;
+  myvertex.cmd |= TA_CMD_VERTEX_EOS;
+  ta_commit_list(&myvertex);  
+}
+
+
+struct Game
+{
+  char dir[256];
+  char filename_base[256];
+  char text[256];
+  Icon icon;
+  Label label;
+};
+
+struct Dir
+{
+  char name[256];
+  char deficon[256];
+};
+
+static Game the_game;
+
+static bool isGame(const char *fn, char *base)
+{
+  int l = strlen(fn);
+  if(l>4 && (!strcasecmp(fn+l-4, ".000") ||
+	     !strcasecmp(fn+l-4, ".SM0"))) {
+    strcpy(base, fn);
+    base[l-4]='\0';
+    return true;
+  }
+  if(!strcasecmp(fn, "00.LFL") ||
+     !strcasecmp(fn, "000.LFL")) {
+    *base = '\0';
+    return true;
+  }
+  return false;
+}
+
+static void checkName(GameDetector *d, Game &game)
+{
+  d->_exe_name = game.filename_base;
+  if(d->detectGame()) {
+    char *n = d->getGameName();
+    strcpy(game.text, n);
+    free(n);
+  } else
+    strcpy(game.text, game.filename_base);
+  d->_exe_name = NULL;
+}
+
+static bool checkExe(const char *dir, const char *f)
+{
+  char fn[520];
+  int fd;
+  sprintf(fn, "%s%s.EXE", dir, f);
+  if((fd = open(fn, O_RDONLY))<0)
+    return false;
+  close(fd);
+  return true;
+}
+
+static bool isIcon(const char *fn)
+{
+  int l = strlen(fn);
+  if(l>4 && !strcasecmp(fn+l-4, ".ICO"))
+    return true;
+  else
+    return false;
+}
+
+static bool loadIcon(Game &game, Dir *dirs, int num_dirs)
+{
+  char icofn[520];
+  sprintf(icofn, "%s%s.ICO", game.dir, game.filename_base);
+  if(game.icon.load(icofn))
+    return true;
+  for(int i=0; i<num_dirs; i++)
+    if(!strcmp(dirs[i].name, game.dir) &&
+       dirs[i].deficon[0]) {
+      sprintf(icofn, "%s%s", game.dir, dirs[i].deficon);      
+      if(game.icon.load(icofn))
+	return true;
+      break;
+    }
+  return false;
+}
+
+static void makeDefIcon(Icon &icon)
+{
+  icon.load(NULL, 0);
+}
+
+static int findGames(GameDetector *d, Game *games, int max)
+{
+  Dir *dirs = new Dir[MAX_DIR];
+  int curr_game = 0, curr_dir = 0, num_dirs = 1;
+  strcpy(dirs[0].name, "/");
+  while(curr_game < max && curr_dir < num_dirs) {
+    dirs[curr_dir].deficon[0] = '\0';
+    DIR *dirp = opendir(dirs[curr_dir++].name);
+    if(dirp) {
+      struct dirent *entry;
+      while((entry = readdir(dirp)))
+	if(entry->d_size < 0) {
+	  if(num_dirs < MAX_DIR) {
+	    strcpy(dirs[num_dirs].name, dirs[curr_dir-1].name);
+	    if(strlen(dirs[num_dirs].name)+strlen(entry->d_name)<255) {
+	      strcat(dirs[num_dirs].name, entry->d_name);
+	      strcat(dirs[num_dirs].name, "/");
+	      num_dirs++;
+	    }
+	  }
+	} else 
+	  if(isIcon(entry->d_name))
+	    strcpy(dirs[curr_dir-1].deficon, entry->d_name);
+	  else if(curr_game < max &&
+	     isGame(entry->d_name, games[curr_game].filename_base)) {
+	    strcpy(games[curr_game].dir, dirs[curr_dir-1].name);
+	    if(!*games[curr_game].filename_base) {
+	      int i;
+	      for(i=strlen(games[curr_game].dir)-1; --i>=0; )
+		if(games[curr_game].dir[i]=='/')
+		  break;
+	      if(i>=0) {
+		strcpy(games[curr_game].filename_base,
+		       games[curr_game].dir+i+1);
+		games[curr_game].filename_base[strlen(games[curr_game].
+						      filename_base)-1]='\0';
+#if 0
+		games[curr_game].dir[i+1]='\0';
+#endif
+	      }
+	      if(checkExe(games[curr_game].dir, "loom"))
+		strcpy(games[curr_game].filename_base, "loomcd");
+	    }
+	    checkName(d, games[curr_game]);
+#if 0
+	    printf("Registered game <%s> in <%s> <%s> because of <%s> <%s>\n",
+		   games[curr_game].text, games[curr_game].dir,
+		   games[curr_game].filename_base,
+		   dirs[curr_dir-1].name, entry->d_name);
+#endif
+	    curr_game++;
+	  }
+      closedir(dirp);
+    }
+  }
+  for(int i=0; i<curr_game; i++)
+    if(!loadIcon(games[i], dirs, num_dirs))
+      makeDefIcon(games[i].icon);
+  delete dirs;
+  return curr_game;
+}
+
+int getCdState()
+{
+  unsigned int param[4];
+  gdGdcGetDrvStat(param);
+  return param[0];
+}
+
+static void drawBackground()
+{
+  draw_solid_quad(20.0, 20.0, 620.0, 460.0,
+		  0xff0000, 0x00ff00, 0x0000ff, 0xffffff);
+}
+
+void waitForDisk()
+{
+  Label lab;
+  int wasopen = 0;
+  ta_sync();
+  void *mark = ta_txmark();
+  lab.create_texture("Please insert game CD.");
+  //printf("waitForDisk, cdstate = %d\n", getCdState());
+  for(;;) {
+    int s = getCdState();
+    if(s >= 6)
+      wasopen = 1;
+    if(s > 0 && s < 6 && wasopen) {
+      cdfs_reinit();
+      chdir("/");
+      chdir("/");
+      ta_sync();
+      ta_txrelease(mark);
+      return;
+    }
+    
+    ta_begin_frame();
+
+    drawBackground();
+
+    ta_commit_end();
+
+    lab.draw(166.0, 200.0, 0xffff2020);
+
+    ta_commit_frame();
+
+    int mousex = 0, mousey = 0;
+    byte shiftFlags;
+
+    int mask = getimask();
+    setimask(15);
+    handleInput(locked_get_pads(), mousex, mousey, shiftFlags);
+    setimask(mask);
+  }
+}
+
+static void drawGameLabel(Game &game, int pal, float x, float y,
+			  unsigned int argb, int fade = 0, float scale = 1.0)
+{
+  unsigned int fade_alpha = (255-fade)<<24;
+
+  game.icon.draw(x, y, x+32.0*scale, y+32.0*scale, pal, 0xffffff|fade_alpha);
+  game.label.draw(x+54.0*scale, y+4.0*scale, argb|fade_alpha, scale);
+}
+
+int gameMenu(Game *games, int num_games)
+{
+  int top_game = 0, selector_pos = 0;
+  int mousex = 0, mousey = 0;
+
+  if(!num_games)
+    return -1;
+
+  for(;;) {
+
+    if(getCdState()>=6)
+      return -1;
+
+    ta_begin_frame();
+    
+    drawBackground();
+    
+    ta_commit_end();
+    
+    float y = 40.0;
+    for(int i=top_game, cnt=0; cnt<10 && i<num_games; i++, cnt++) {
+      int pal = 48+(i&15);
+
+      if(cnt == selector_pos)
+	draw_trans_quad(100.0, y, 590.0, y+32.0,
+			0x7000ff00, 0x7000ff00, 0x7000ff00, 0x7000ff00);
+
+      games[i].icon.set_palette(pal);
+      drawGameLabel(games[i], pal, 50.0, y, (cnt == selector_pos?
+					     0xffff00 : 0xffffff));
+      y += 40.0;
+    }
+
+    ta_commit_frame();
+
+    byte shiftFlags;
+    int event;
+
+    int mask = getimask();
+    setimask(15);
+    event = handleInput(locked_get_pads(), mousex, mousey, shiftFlags);
+    setimask(mask);
+    
+    if(event==-OSystem::EVENT_LBUTTONDOWN || event==13 || event==319) {
+      int selected_game = top_game + selector_pos;
+
+      for(int fade=0; fade<=256; fade+=4) {
+
+	unsigned int fade_colour = 0x00ffffff | ((255-fade)<<24);
+
+	ta_begin_frame();
+    
+	drawBackground();
+    
+	ta_commit_end();
+    
+	float y = 40.0;
+
+	if(fade < 256)
+	  for(int i=top_game, cnt=0; cnt<10 && i<num_games; 
+	      i++, cnt++, y += 40.0)
+	    if(cnt != selector_pos)
+	      drawGameLabel(games[i], 48+(i&15), 50.0, y, 0xffffff, fade);
+
+	y = (40.0/256.0 * (selector_pos + 1))*(256-fade) + 80.0/256.0*fade;
+	float x = 50.0/256.0*(256-fade) + 160.0/256.0*fade;
+	float scale = 1.0+9.0/256.0*fade;
+
+	drawGameLabel(games[selector_pos], 48+(selected_game&15), x, y,
+		      0xffff00, 0, scale);
+
+	ta_commit_frame();
+      }
+      return selected_game;
+    }
+
+    if(mousey>=16) {
+      if(selector_pos + top_game + 1 < num_games)
+	if(++selector_pos >= 10) {
+	  --selector_pos;
+	  ++top_game;
+	}
+      mousey -= 16;
+    } else if(mousey<=-16) {
+      if(selector_pos + top_game > 0)
+	if(--selector_pos < 0) {
+	  ++selector_pos;
+	  --top_game;
+	}
+      mousey += 16;
+    }
+  }
+}
+
+bool selectGame(GameDetector *d, char *&ret, char *&dir_ret, Icon &icon)
+{
+  Game *games = new Game[MAX_GAMES];
+  int selected, num_games;
+
+  ta_sync();
+  void *mark = ta_txmark();
+
+  for(;;) {
+    num_games = findGames(d, games, MAX_GAMES);
+
+    for(int i=0; i<num_games; i++) {
+      games[i].icon.create_texture();
+      games[i].label.create_texture(games[i].text);
+    }
+
+    selected = gameMenu(games, num_games);
+
+    ta_sync();
+    ta_txrelease(mark);
+
+    if(selected == -1)
+      waitForDisk();
+    else
+      break;
+
+  }
+
+  if(selected >= num_games)
+    selected = -1;
+
+  if(selected >= 0)
+    the_game = games[selected];
+
+  delete games;
+
+  if(selected>=0) {
+#if 0
+    chdir(the_game.dir);
+#else
+    chdir("/");
+    static char dirarg[258];
+    sprintf(dirarg, "-p%s", the_game.dir);
+    dir_ret = dirarg;
+#endif
+    ret = the_game.filename_base;
+    icon = the_game.icon;
+    return true;
+  } else
+    return false;
+}
diff --git a/backends/dc/vmsave.cpp b/backends/dc/vmsave.cpp
new file mode 100644
index 0000000000..34bf2e40fa
--- /dev/null
+++ b/backends/dc/vmsave.cpp
@@ -0,0 +1,266 @@
+/* ScummVM - Scumm Interpreter
+ * Dreamcast port
+ * Copyright (C) 2002  Marcus Comstedt
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "scumm.h"
+#include "mididrv.h"
+#include "gameDetector.h"
+#include "dc.h"
+#include "icon.h"
+#include "saveload.h"
+
+#include <ronin/zlib.h>
+
+
+// Savegame can not be bigger than this, even before compression
+#define MAX_SAVE_SIZE (128*1024)
+
+
+enum vmsaveResult {
+  VMSAVE_OK,
+  VMSAVE_NOVM,
+  VMSAVE_NOSPACE,
+  VMSAVE_WRITEERROR,  
+};
+
+
+static int lastvm=-1;
+
+static vmsaveResult trySave(GameDetector *d, const char *data, int size,
+			    const char *filename, class Icon &icon, int vm)
+{
+  struct vmsinfo info;
+  struct superblock super;
+  struct vms_file file;
+  struct vms_file_header header;
+  struct timestamp tstamp;
+  struct tm tm;
+  time_t t;
+  unsigned char iconbuffer[512+32];
+
+  if(!vmsfs_check_unit(vm, 0, &info))
+    return VMSAVE_NOVM;
+  if(!vmsfs_get_superblock(&info, &super))
+    return VMSAVE_NOVM;
+  int free_cnt = vmsfs_count_free(&super);
+  if(vmsfs_open_file(&super, filename, &file))
+    free_cnt += file.blks;
+  if(((128+512+size+511)>>9) > free_cnt)
+    return VMSAVE_NOSPACE;
+
+  memset(&header, 0, sizeof(header));
+  strncpy(header.shortdesc, "ScummVM savegame", 16);
+  char *game_name = d->getGameName();
+  strncpy(header.longdesc, game_name, 32);
+  free(game_name);
+  strncpy(header.id, "ScummVM", 16);
+  icon.create_vmicon(iconbuffer);
+  header.numicons = 1;
+  memcpy(header.palette, iconbuffer, sizeof(header.palette));
+  time(&t);
+  tm = *localtime(&t);
+  tstamp.year = tm.tm_year+1900;
+  tstamp.month = tm.tm_mon+1;
+  tstamp.day = tm.tm_mday;
+  tstamp.hour = tm.tm_hour;
+  tstamp.minute = tm.tm_min;
+  tstamp.second = tm.tm_sec;
+  tstamp.wkday = (tm.tm_wday+6)%7;
+
+  vmsfs_beep(&info, 1);
+
+  vmsfs_errno = 0;
+  if(!vmsfs_create_file(&super, filename, &header,
+			iconbuffer+sizeof(header.palette), NULL,
+			data, size, &tstamp)) {
+    fprintf(stderr, "%s\n", vmsfs_describe_error());
+    vmsfs_beep(&info, 0);
+    return VMSAVE_WRITEERROR;
+  }
+
+  vmsfs_beep(&info, 0);
+  return VMSAVE_OK;
+}
+
+static bool tryLoad(char *&buffer, int &size, const char *filename, int vm)
+{
+  struct vmsinfo info;
+  struct superblock super;
+  struct vms_file file;
+  struct vms_file_header header;
+  struct timestamp tstamp;
+  struct tm tm;
+  time_t t;
+  unsigned char iconbuffer[512+32];
+
+  if(!vmsfs_check_unit(vm, 0, &info))
+    return false;
+  if(!vmsfs_get_superblock(&info, &super))
+    return false;
+  if(!vmsfs_open_file(&super, filename, &file))
+    return false;
+  
+  buffer = new char[size = file.size];
+
+  if(vmsfs_read_file(&file, (unsigned char *)buffer, size))
+    return true;
+
+  delete buffer;
+  return false;
+}
+
+vmsaveResult writeSaveGame(GameDetector *d, const char *data, int size,
+			   const char *filename, class Icon &icon)
+{
+  vmsaveResult r, res = VMSAVE_NOVM;
+
+  if(lastvm >= 0 &&
+     (res = trySave(d, data, size, filename, icon, lastvm)) == VMSAVE_OK)
+    return res;
+
+  for(int i=0; i<24; i++)
+    if((r = trySave(d, data, size, filename, icon, i)) == VMSAVE_OK) {
+      lastvm = i;
+      return r;
+    } else if(r > res)
+      res = r;
+
+  return res;
+}
+
+bool readSaveGame(char *&buffer, int &size, const char *filename)
+{
+  if(lastvm >= 0 &&
+     tryLoad(buffer, size, filename, lastvm))
+    return true;
+
+  for(int i=0; i<24; i++)
+    if(tryLoad(buffer, size, filename, i)) {
+      lastvm = i;
+      return true;
+    }
+
+  return false;
+}
+
+
+struct vmStreamContext {
+  bool issave;
+  char *buffer;
+  int pos, size;
+  char filename[16];
+};
+
+bool SerializerStream::fopen(const char *filename, const char *mode)
+{
+  vmStreamContext *c = new vmStreamContext;
+  context = c;
+  if(strchr(mode, 'w')) {
+    c->issave = true;
+    strncpy(c->filename, filename, 16);
+    c->pos = 0;
+    c->buffer = new char[c->size = MAX_SAVE_SIZE];
+    return true;
+  } else if(readSaveGame(c->buffer, c->size, filename)) {
+    if(c->size > 0 && c->buffer[0] != 'S') {
+      // Data does not start with "SCVM".  Maybe compressed?
+      char *expbuf = new char[MAX_SAVE_SIZE];
+      unsigned long destlen = MAX_SAVE_SIZE;
+      if(!uncompress((Bytef*)expbuf, &destlen, (Bytef*)c->buffer, c->size)) {
+	delete(c->buffer);
+	c->buffer = expbuf;
+	c->size = destlen;
+      } else delete expbuf;
+    }
+    c->issave = false;
+    c->pos = 0;
+    return true;
+  } else {
+    delete c;
+    context = NULL;
+    return false;
+  }
+}
+
+void SerializerStream::fclose()
+{
+  extern GameDetector detector;
+  extern Icon icon;
+
+  if(context) {
+    vmStreamContext *c = (vmStreamContext *)context;
+    if(c->issave) {
+      if(c->pos) {
+	// Try compression
+	char *compbuf = new char[c->pos];
+	unsigned long destlen = c->pos;
+	if(!compress((Bytef*)compbuf, &destlen, (Bytef*)c->buffer, c->pos)) {
+	  delete c->buffer;
+	  c->buffer = compbuf;
+	  c->pos = destlen;
+	} else delete compbuf;
+      }
+      writeSaveGame(&detector, c->buffer, c->pos,
+		    c->filename, icon);
+    }
+    delete c->buffer;
+    delete c;
+    context = NULL;
+  }
+}
+
+int SerializerStream::fread(void *buf, int size, int cnt)
+{
+  vmStreamContext *c = (vmStreamContext *)context;
+
+  if (!c || c->issave)
+    return -1; 
+
+  int nbyt = size*cnt;
+  if (c->pos + nbyt > c->size) {
+    cnt = (c->size - c->pos)/size;
+    nbyt = size*cnt;
+  }
+  if (nbyt)
+    memcpy(buf, c->buffer + c->pos, nbyt);
+  c->pos += nbyt;
+  return cnt;
+}
+
+int SerializerStream::fwrite(void *buf, int size, int cnt)
+{
+  vmStreamContext *c = (vmStreamContext *)context;
+
+  if (!c || !c->issave)
+    return -1;
+
+  int nbyt = size*cnt;
+  if (c->pos + nbyt > c->size) {
+    cnt = (c->size - c->pos)/size;
+    nbyt = size*cnt;
+  }
+  if (nbyt)
+    memcpy(c->buffer + c->pos, buf, nbyt);
+  c->pos += nbyt;
+  return cnt;
+}
+
diff --git a/backends/mac/Carbon.r b/backends/mac/Carbon.r
new file mode 100644
index 0000000000..a296c97b26
--- /dev/null
+++ b/backends/mac/Carbon.r
@@ -0,0 +1,111 @@
+/*
+ *  Permit this Carbon application to launch on OS X
+ *
+ *  © 1997-2000 Metrowerks Corp.
+ *
+ *  Questions and comments to:
+ *       <mailto:support@metrowerks.com>
+ *       <http://www.metrowerks.com/>
+ */
+ 
+#include "MacTypes.r"
+#include "Dialogs.r"
+#include "Balloons.r"
+#include "Menus.r"
+#include "Finder.r"
+#include "Quickdraw.r"
+#include "Icons.r"
+#include "Processes.r"
+#include "Controls.r"
+
+/*----------------------------carb ¥ Carbon on OS X launch information --------------------------*/
+type 'carb' {
+};
+
+
+resource 'carb'(0) {
+};
+
+resource 'ALRT' (129) {
+	{55, 39, 153, 407},
+	128,
+	{	/* array: 4 elements */
+		/* [1] */
+		OK, visible, sound1,
+		/* [2] */
+		OK, visible, sound1,
+		/* [3] */
+		OK, visible, sound1,
+		/* [4] */
+		OK, visible, sound1
+	},
+	alertPositionParentWindowScreen
+};
+
+resource 'DITL'(128) {
+	{
+		{8, 74, 61, 356},
+		StaticText {
+			disabled,
+			"^0"
+		},
+		
+		{70, 299, 90, 357},
+		Button {
+			enabled,
+			"OK"
+		}
+	}
+};
+
+resource 'MENU'(999) {
+	999, 63, allEnabled, enabled, "Please Select a GameÉ",
+	{
+		"Maniac Mansion (C64)", noIcon, noKey, noMark, plain,
+		"Zak McKracken and the Alien Mindbenders (C64)", noIcon, noKey, noMark, plain,
+		"Maniac Mansion", noIcon, noKey, noMark, plain,
+		"Zak McKracken and the Alien Mindbenders", noIcon, noKey, noMark, plain,
+		"Indiana Jones and the Last Crusade", noIcon, noKey, noMark, plain,
+		"Indiana Jones and the Last Crusade (256)", noIcon, noKey, noMark, plain,
+		"Zak McKracken and the Alien Mindbenders (256)", noIcon, noKey, noMark, plain,
+		"Loom", noIcon, noKey, noMark, plain,
+		"Monkey Island 1 (EGA)", noIcon, noKey, noMark, plain,
+		"Monkey Island 1 (256 color Floppy version)", noIcon, noKey, noMark, plain,
+		"Loom (256 color CD version)", noIcon, noKey, noMark, plain,
+		"Monkey Island 1", noIcon, noKey, noMark, plain,
+		"Monkey Island 1 (alt)", noIcon, noKey, noMark, plain,
+		"Monkey Island 2: LeChuck's revenge", noIcon, noKey, noMark, plain,
+		"Indiana Jones 4 and the Fate of Atlantis", noIcon, noKey, noMark, plain,
+		"Indiana Jones 4 and the Fate of Atlantis (Demo)", noIcon, noKey, noMark, plain,
+		"Day Of The Tentacle", noIcon, noKey, noMark, plain,
+		"Day Of The Tentacle (Demo)", noIcon, noKey, noMark, plain,
+		"Sam & Max", noIcon, noKey, noMark, plain,
+		"Sam & Max (Demo)", noIcon, noKey, noMark, plain,
+		"Full Throttle", noIcon, noKey, noMark, plain,
+		"The Dig", noIcon, noKey, noMark, plain,
+		"The Curse of Monkey Island", noIcon, noKey, noMark, plain,
+		"-", noIcon, noKey, noMark, plain,
+		"Simon the Sorcerer 1 (DOS)", noIcon, noKey, noMark, plain,
+		"Simon the Sorcerer 1 (Windows)", noIcon, noKey, noMark, plain,
+		"Simon the Sorcerer 2 (Windows)", noIcon, noKey, noMark, plain
+	}		
+};
+
+resource 'MENU'(1000) {
+	1000, 63, allEnabled, enabled, apple,
+	{
+		"About ScummVMÉ", noIcon, noKey, noMark, plain,
+		"-", noIcon, noKey, noMark, plain
+	}
+};
+
+resource 'MENU'(1001) {
+	1001, 63, allEnabled, enabled, "File",
+	{
+		"New Game", noIcon, "N", noMark, plain,
+		"Open Game", noIcon, "O", noMark, plain,
+		"Save Game", noIcon, "S", noMark, plain,
+		"-", noIcon, noKey, noMark, plain,
+		"Q", noIcon, "Q", noMark, plain
+	}
+};
\ No newline at end of file
diff --git a/backends/mac/CarbonPort-ReadMe.txt b/backends/mac/CarbonPort-ReadMe.txt
new file mode 100644
index 0000000000..262b9a50f8
--- /dev/null
+++ b/backends/mac/CarbonPort-ReadMe.txt
@@ -0,0 +1,34 @@
+README FOR THE MAC CARBON PORT
+
+Runs on Mac OS X 10.1 (could also run on 10.0.x, but not tested), and Mac OS 8.6 or later (with CarbonLib
+installed).
+
+HOW TO COMPILE?
+Launch the scummvm.mcp file in CodeWarrior and choose one of the Targets to compile. For just playing,
+you should choose "ScummVM Final", the Debug one is just for Developing.
+Binaries will come up to the Website with the release 0.2.0, which will be hopefully soon.
+
+NOTES:
+Put the games in a folder in the same directory as ScummVM, which have the name of the Data Files, like this:
+
+-- - ScummVM
+  \- monkey2-
+             \- monkey2.000
+              - monkey2.001
+
+
+Hope this will help you :)
+
+CHANGES:
+- Thanks to Florent Boudet, QuickTime MIDI has been added, although it currently only works with DOTT
+- Added SFX Sound Support
+- Now draws the Games Cursors
+
+BUGS:
+- On OS X it got some Problems with KeyDown-Events (seems to work now, most of the time)
+- Bad behaviour of the Application towards other, will be fixed soon.
+- Some minor bugs
+
+If you find any bugs, just make a Bug Report on our SourceForge Page.
+
+-- Mutle
\ No newline at end of file
diff --git a/backends/mac/mac.cpp b/backends/mac/mac.cpp
new file mode 100644
index 0000000000..f22d72666b
--- /dev/null
+++ b/backends/mac/mac.cpp
@@ -0,0 +1,1790 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001/2002  Mutwin Kraus (Mac Port) and The ScummVM Project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include <Carbon.h>
+#include <sioux.h>
+
+#include "stdafx.h"
+#include "scumm.h"
+#include "mididrv.h"
+#include "gameDetector.h"
+//#include "mp3_cd.h"
+#include "gui.h"
+//#include "gameDetector.h"
+#include "scaler.h"
+
+#define MAX(a,b) (((a)<(b)) ? (b) : (a))
+#define MIN(a,b) (((a)>(b)) ? (b) : (a))
+
+class OSystem_MAC : public OSystem {
+public:
+	// Set colors of the palette
+	void set_palette(const byte *colors, uint start, uint num);
+
+	// Set the size of the video bitmap.
+	// Typically, 320x200
+	void init_size(uint w, uint h);
+
+	// Draw a bitmap to screen.
+	// The screen will not be updated to reflect the new bitmap
+	void copy_rect(const byte *buf, int pitch, int x, int y, int w, int h);
+
+	// Update the dirty areas of the screen
+	void update_screen();
+
+	// Either show or hide the mouse cursor
+	bool show_mouse(bool visible);
+	
+	// Set the position of the mouse cursor
+	void set_mouse_pos(int x, int y);
+	
+	// Set the bitmap that's used when drawing the cursor.
+	void set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y);
+	
+	// Shaking is used in SCUMM. Set current shake position.
+	void set_shake_pos(int shake_pos);
+		
+	// Get the number of milliseconds since the program was started.
+	uint32 get_msecs();
+	
+	// Delay for a specified amount of milliseconds
+	void delay_msecs(uint msecs);
+	
+	// Create a thread
+	void *create_thread(ThreadProc *proc, void *param);
+	
+	// Get the next event.
+	// Returns true if an event was retrieved.	
+	bool poll_event(Event *event);
+	
+	// Set function that generates samples 
+	bool set_sound_proc(void *param, SoundProc *proc, byte sound);
+		
+	// Poll cdrom status
+	// Returns true if cd audio is playing
+	bool poll_cdrom();
+
+	// Play cdrom audio track
+	void play_cdrom(int track, int num_loops, int start_frame, int end_frame);
+
+	// Stop cdrom audio track
+	void stop_cdrom();
+
+	// Update cdrom audio status
+	void update_cdrom();
+
+	// Add a new callback timer
+	void set_timer(int timer, int (*callback)(int))		{ /* FIXME - TODO */ }
+
+	// Mutex handling
+	void *create_mutex(void)			{ return NULL; /* FIXME - TODO */ }
+	void lock_mutex(void *mutex)		{ /* FIXME - TODO */ }
+	void unlock_mutex(void *mutex)		{ /* FIXME - TODO */ }
+	void delete_mutex(void *mutex)		{ /* FIXME - TODO */ }
+
+	// Quit
+	void quit();
+
+	// Set a parameter
+	uint32 property(int param, Property *value);
+
+	static OSystem *create(int gfx_mode, bool full_screen);
+	
+	void sound_callback(SndChannel *chan, SndCommand *cmd_passed);
+private:
+	typedef void TwoXSaiProc(uint8 *srcPtr, uint32 srcPitch, uint8 *deltaPtr,
+								uint8 *dstPtr, uint32 dstPitch, int width, int height);
+	
+	GWorldPtr screenBuf;
+	WindowRef wref;
+	CTabHandle pal;	
+	Rect blit_rect;
+
+	enum {
+		DF_WANT_RECT_OPTIM			= 1 << 0,
+		DF_REAL_8BIT				= 1 << 1,
+		DF_SEPARATE_TEMPSCREEN		= 1 << 2,
+		DF_UPDATE_EXPAND_1_PIXEL	= 1 << 3
+	};
+
+	int _mode;
+	bool _full_screen;
+	bool _mouse_visible;
+	bool _mouse_drawn;
+	uint32 _mode_flags;
+	byte _internal_scaling;
+
+	bool force_full; //Force full redraw on next update_screen
+	bool cksum_valid;
+
+	enum {
+		NUM_DIRTY_RECT = 100,
+
+		MAX_MOUSE_W = 40,
+		MAX_MOUSE_H = 40,
+		MAX_SCALING = 3
+	};
+	
+	int SCREEN_WIDTH, SCREEN_HEIGHT, CKSUM_NUM;
+	Rect *dirty_rect_list;
+	int num_dirty_rects;
+	uint32 *dirty_checksums;
+
+	int scaling;
+
+	/* CD Audio */
+	int cd_track, cd_num_loops, cd_start_frame, cd_end_frame;
+	uint32 cd_end_time, cd_stop_time, cd_next_second;
+
+	struct MousePos {
+		int16 x,y,w,h;
+	};
+
+	byte *_ms_buf;
+	byte *_ms_backup;
+	MousePos _ms_cur;
+	MousePos _ms_old;
+	int16 _ms_hotspot_x;
+	int16 _ms_hotspot_y;
+	int _current_shake_pos;
+
+	byte*	_gfx_buf;	/* Graphics memory */
+	int16 *_sai_buf, *_tmp_buf;
+	uint _palette_changed_first, _palette_changed_last;
+	
+	TwoXSaiProc *_sai_func;
+
+	void add_dirty_rgn_auto(const byte *buf);
+	void mk_checksums(const byte *buf);
+
+	static void fill_sound(void *userdata, uint8 * stream, int len);
+	
+	void add_dirty_rect(int x, int y, int w, int h);
+
+	void draw_mouse();
+	void undraw_mouse();
+
+	void load_gfx_mode();
+	void unload_gfx_mode();
+
+	void hotswap_gfx_mode();
+
+	void get_320x200_image(byte *buf);
+	
+	void init_mac_stuff();
+	void set_scaling();
+	void blit_to_screen();
+	void update_rects();
+	
+	static void autosave(Scumm * scumm);
+	
+	UInt8 *buffer[2];
+	CmpSoundHeader header;
+	SndChannelPtr channel;
+	int size;
+	SoundProc *sndProc;
+	void * parameter;
+};
+
+KeyMap fKeyMap;
+
+Boolean CommandKeyDown()
+{
+	GetKeys(fKeyMap);							// get info
+	if (fKeyMap[1] & 0x8000)
+		return true;
+	else
+		return false;
+}
+
+static unsigned char *CToPascal(char *str) {
+	register char *p,*q;
+	register long len;
+
+	len = strlen(str);
+	if (len > 255) len = 255;
+	p = str + len;
+	q = p-1;
+	while (p != str) 
+	 *p-- = *q--;
+	*str = len;
+	return((unsigned char *)str);
+}
+
+static char *PascalToC(unsigned char *str) {
+	register unsigned char *p,*q,*end;
+
+	end = str + *str;
+	q = (p=str) + 1;
+
+	while (p < end) 
+		*p++ = *q++;
+	*p = '\0';
+
+	return((char *)str);
+}
+
+const EventTypeSpec kCmdEvents[] = 
+{
+	{ kEventClassMouse, kEventMouseDown },
+	{ kEventClassMouse, kEventMouseUp },
+	{ kEventClassMouse, kEventMouseMoved },
+	{ kEventClassKeyboard, kEventRawKeyDown },
+	{ kEventClassCommand, kEventProcessCommand }
+};
+
+const EventTypeSpec kWindowEvents[] =
+{
+	{ kEventClassWindow, kEventWindowDrawContent },
+	{ kEventClassWindow, kEventWindowHandleContentClick },
+	{ kEventClassWindow, kEventWindowClose }
+};
+
+pascal OSErr QuitEventHandler(const AppleEvent *theEvent, AppleEvent *theReply, SInt32 refCon)
+{
+	//OSystem_MAC::quit();
+	return(noErr);
+}
+
+enum
+{
+	kNewGameCmd		= 'newG',
+	kQuitCmd		= kHICommandQuit,
+	kOpenGameCmd	= 'opnG',
+	kSaveGameCmd	= 'savG',
+	kPrefsCmd		= kHICommandPreferences,
+	kAboutCmd		= 'abtG'
+};
+
+ControlRef radioGroupRef, musicVolumeSlider, masterVolumeSlider;
+char *gameTitle;
+ControlRef    popUpControlRef, checkBoxControlRef;
+
+OSStatus prefsEventHandler(EventHandlerCallRef eventHandlerCallRef,EventRef eventRef,
+                             void *userData)
+{
+  OSStatus   result = eventNotHandledErr;
+  UInt32     eventClass;
+  UInt32     eventKind;
+  ControlRef controlRef;
+  ControlID  controlID;
+
+  eventClass = GetEventClass(eventRef);
+  eventKind  = GetEventKind(eventRef);
+
+  if(eventClass == kEventClassControl)
+  {
+    if(eventKind == kEventControlHit)
+    {
+      GetEventParameter(eventRef,kEventParamDirectObject,typeControlRef,NULL,
+                        sizeof(ControlRef),NULL,&controlRef);
+
+      GetControlID(controlRef,&controlID);
+      if(controlID.id == 'okay')
+      {
+        /*scumm->_noSubtitles = (Boolean)!GetControlValue(checkBoxControlRef);
+        short scale = GetControlValue(radioGroupRef);
+        if(scale != scumm->_scale)
+        	wm->ChangeScaling(scale);
+        short music_vol = GetControlValue(musicVolumeSlider);
+        if(music_vol != sound.get_music_volume())
+        	sound.set_music_volume(music_vol);
+        short master_vol = GetControlValue(masterVolumeSlider);
+        if(master_vol != sound.get_master_volume())
+        	sound.set_master_volume(master_vol);*/
+        QuitAppModalLoopForWindow((WindowRef)userData);
+        DisposeWindow((WindowRef)userData);
+        result = noErr;
+      }
+    }
+  }
+}
+
+void Preferences()
+{
+	WindowRef	prefsWin;
+	OSStatus    osError = noErr;
+	Rect        rect = { 0,0,210,300 };
+	Rect        okButtonRect;
+	ControlID	controlID;
+	ControlRef	controlRef;
+	EventTypeSpec dialogEvents[] = { kEventClassControl, kEventControlHit };
+  	
+	osError = CreateNewWindow(kMovableModalWindowClass,kWindowStandardHandlerAttribute,&rect, &prefsWin);
+	SetWTitle(prefsWin, "\pPreferences");
+	RepositionWindow(prefsWin,FrontWindow(),kWindowAlertPositionOnMainScreen);
+	SetThemeWindowBackground(prefsWin,kThemeBrushDialogBackgroundActive,false);
+	CreateRootControl(prefsWin,&controlRef);
+	
+	SetRect(&rect, 5, 5, 150, 21);
+	
+	CreateStaticTextControl(prefsWin, &rect, CFSTR("ScummVM Preferences"), NULL, &controlRef);
+	AutoEmbedControl(controlRef, prefsWin);
+	
+	SetRect(&okButtonRect, 225, 180, 295, 200);
+	
+    CreatePushButtonControl(prefsWin,&okButtonRect,CFSTR("OK"),&controlRef);
+    SetWindowDefaultButton(prefsWin,controlRef);
+    controlID.id = 'okay';
+    SetControlID(controlRef,&controlID);
+    AutoEmbedControl(controlRef,prefsWin);
+    
+    SetRect(&rect, 150, 35, 260, 51);
+    
+    CreateCheckBoxControl(prefsWin,&rect, CFSTR("Subtitles"), 1, true, &checkBoxControlRef);
+    AutoEmbedControl(checkBoxControlRef, prefsWin);
+    
+    //if(scumm->_noSubtitles)
+    	SetControlValue(checkBoxControlRef, false);
+    
+    OffsetRect(&rect, 0, 20);
+    
+    CreateCheckBoxControl(prefsWin,&rect, CFSTR("Fullscreen"), 0, true, &controlRef);
+    AutoEmbedControl(controlRef, prefsWin);
+    DeactivateControl(controlRef);
+    
+    Rect RadioGroupRect;
+    SetRect(&RadioGroupRect, 5, 35, 120, 100);
+    CreateRadioGroupControl(prefsWin, &RadioGroupRect, &radioGroupRef);
+    AutoEmbedControl(radioGroupRef, prefsWin);
+    
+    ControlRef radioButton;
+    
+    Rect RadioButtonRect;	
+    SetRect(&RadioButtonRect, 5, 35, 120, 51);
+    CreateRadioButtonControl(prefsWin, &RadioButtonRect, CFSTR("Scaling 1x"), 0, true, &radioButton);
+    AutoEmbedControl(radioButton, prefsWin);
+    	
+    OffsetRect(&RadioButtonRect, 0, 20);
+    CreateRadioButtonControl(prefsWin, &RadioButtonRect, CFSTR("Scaling 2x"), 0, true, &radioButton);
+    AutoEmbedControl(radioButton, prefsWin);
+    
+    OffsetRect(&RadioButtonRect, 0, 20);
+    CreateRadioButtonControl(prefsWin, &RadioButtonRect, CFSTR("Scaling 3x"), 0, true, &radioButton);
+    AutoEmbedControl(radioButton, prefsWin);
+    
+    //SetControlValue(radioGroupRef, scumm->_scale);
+    
+    SetRect(&rect, 5, 110, 175, 146);
+    
+    CreateSliderControl(prefsWin, &rect, 100, 1, 100,
+    		kControlSliderPointsDownOrRight, 10, false, NULL, &musicVolumeSlider);
+    AutoEmbedControl(musicVolumeSlider, prefsWin);
+    
+    OffsetRect(&rect, 0, 36);
+    
+    CreateSliderControl(prefsWin, &rect, 100, 1, 100,
+    		kControlSliderPointsDownOrRight, 10, false, NULL, &masterVolumeSlider);
+    AutoEmbedControl(masterVolumeSlider, prefsWin);
+    
+    OffsetRect(&rect, 180, -36);
+    
+    CreateStaticTextControl(prefsWin, &rect, CFSTR("Music Volume"), NULL, &controlRef);
+	AutoEmbedControl(controlRef, prefsWin);
+	
+	OffsetRect(&rect, 0, 36);
+    
+    CreateStaticTextControl(prefsWin, &rect, CFSTR("Master Volume"), NULL, &controlRef);
+	AutoEmbedControl(controlRef, prefsWin);
+    
+    InstallWindowEventHandler(prefsWin, NewEventHandlerUPP((EventHandlerProcPtr) prefsEventHandler),
+                              GetEventTypeCount(dialogEvents),dialogEvents,prefsWin,NULL);
+    ShowWindow(prefsWin);
+    osError = RunAppModalLoopForWindow(prefsWin);
+}
+
+void LaunchGame(int id)
+{
+	switch(id)
+	{
+		case 6:
+			gameTitle = "indy3";
+		break;
+		
+		case 7:
+			gameTitle = "zak256";
+		break;
+	
+		case 8:
+			gameTitle = "loom";
+		break;
+		
+		case 9:
+			gameTitle = "monkeyEGA";
+		break;
+		
+		case 10:
+			gameTitle = "monkeyVGA";
+		break;
+		
+		case 11:
+			gameTitle = "loomcd";
+		break;
+		
+		case 12:
+			gameTitle = "monkey";
+		break;
+		
+		case 13:
+			gameTitle = "monkey1";
+		break;
+		
+		case 14:
+			gameTitle = "monkey2";
+		break;
+		
+		case 15:
+			gameTitle = "atlantis";
+		break;
+		
+		case 16:
+			gameTitle = "playfate";
+		break;
+		
+		case 17:
+			gameTitle = "tentacle";
+		break;
+		
+		case 18:
+			gameTitle = "dottdemo";
+		break;
+		
+		case 19:
+			gameTitle = "samnmax";
+		break;
+		
+		case 20:
+			gameTitle = "snmdemo";
+		break;
+		
+		case 21:
+			gameTitle = "ft";
+		break;
+		
+		case 22:
+			gameTitle = "dig";
+		break;
+		
+		case 25:
+			gameTitle = "simon1dos";
+		break;
+		
+		case 26:
+			gameTitle = "simon1win";
+		break;
+		
+		case 27:
+			gameTitle = "simon2win";
+		break;
+	}
+}
+
+OSStatus dialogEventHandler(EventHandlerCallRef eventHandlerCallRef,EventRef eventRef,
+                             void *userData)
+{
+  OSStatus   result = eventNotHandledErr;
+  UInt32     eventClass;
+  UInt32     eventKind;
+  ControlRef controlRef;
+  ControlID  controlID;
+
+  eventClass = GetEventClass(eventRef);
+  eventKind  = GetEventKind(eventRef);
+
+  if(eventClass == kEventClassControl)
+  {
+    if(eventKind == kEventControlHit)
+    {
+
+      GetEventParameter(eventRef,kEventParamDirectObject,typeControlRef,NULL,
+                        sizeof(ControlRef),NULL,&controlRef);
+
+      GetControlID(controlRef,&controlID);
+      if(controlID.id == 'okay')
+      {
+        QuitAppModalLoopForWindow((WindowRef)userData);
+        LaunchGame(GetControlValue(popUpControlRef));
+        
+        DisposeWindow((WindowRef)userData);
+        result = noErr;
+      }
+      else if(controlID.id == 'cncl')
+      {
+      	QuitAppModalLoopForWindow((WindowRef)userData);
+      	DisposeWindow((WindowRef)userData);
+      	ExitToShell();
+      }
+    }
+  }
+  return result;
+}
+
+char* SelectGame()
+{
+	WindowRef 	aboutWin;
+	OSStatus      osError = noErr;
+	Rect          rect = { 0,0,120,350 };
+	Rect          pushButtonRect = { 75,250,96,330 };
+	Rect		popupRect = { 10, 10, 26, 330 };
+	ControlID	controlID;
+	ControlRef	controlRef;
+	Rect		checkboxRect = { 36, 10, 50, 80 };
+	EventTypeSpec dialogEvents[] = { kEventClassControl, kEventControlHit };
+  	
+  	InitCursor();
+  	
+  	SIOUXSettings.autocloseonquit    = true;
+    SIOUXSettings.asktosaveonclose    = false;
+    SIOUXSettings.showstatusline    = false;
+    SIOUXSettings.fontsize            = 9;
+    GetFNum("\pMonaco",&SIOUXSettings.fontid);
+   	SIOUXSettings.standalone        = false;
+   	SIOUXSettings.setupmenus		= false;
+   	SIOUXSettings.toppixel			= 40;
+   	SIOUXSettings.leftpixel			= 5;
+  	
+	osError = CreateNewWindow(kMovableModalWindowClass,kWindowStandardHandlerAttribute,&rect, &aboutWin);
+	SetWTitle(aboutWin, "\pPlease Select a GameÉ");
+	RepositionWindow(aboutWin,FrontWindow(),kWindowAlertPositionOnMainScreen);
+	SetThemeWindowBackground(aboutWin,kThemeBrushDialogBackgroundActive,false);
+	CreateRootControl(aboutWin,&controlRef);
+
+    CreatePushButtonControl(aboutWin,&pushButtonRect,CFSTR("OK"),&controlRef);
+    SetWindowDefaultButton(aboutWin,controlRef);
+    controlID.id = 'okay';
+    SetControlID(controlRef,&controlID);
+    AutoEmbedControl(controlRef,aboutWin);
+   
+    OffsetRect(&pushButtonRect, -100, 0);
+    CreatePushButtonControl(aboutWin,&pushButtonRect,CFSTR("Cancel"),&controlRef);
+    SetWindowCancelButton(aboutWin,controlRef);
+    controlID.id = 'cncl';
+    SetControlID(controlRef,&controlID);
+    AutoEmbedControl(controlRef,aboutWin);
+            
+    CreatePopupButtonControl(aboutWin, &popupRect, CFSTR("Game: "), 999, false, -1, 0, NULL, &popUpControlRef);
+    SetWindowDefaultButton(aboutWin,popUpControlRef);
+    controlID.id = 'game';
+
+    SetControlID(popUpControlRef,&controlID);
+    
+	AutoEmbedControl(controlRef,aboutWin);
+
+    InstallWindowEventHandler(aboutWin, NewEventHandlerUPP((EventHandlerProcPtr) dialogEventHandler),
+                              GetEventTypeCount(dialogEvents),dialogEvents,aboutWin,NULL);
+    ShowWindow(aboutWin);
+    osError = RunAppModalLoopForWindow(aboutWin);
+    return gameTitle;
+}
+
+OSystem *OSystem_MAC::create(int gfx_mode, bool full_screen) {
+	Rect rectWin;
+	OSystem_MAC *syst = new OSystem_MAC();
+	syst->_mode = gfx_mode;
+	syst->_full_screen = full_screen;
+
+	/* Macintosh init */
+	syst->init_mac_stuff();
+	
+	return syst;
+}
+
+void OSystem_MAC::autosave(Scumm * scumm)
+{
+	scumm->_doAutosave = true;
+
+	return interval;
+}
+
+OSystem *OSystem_MAC_create(int gfx_mode, bool full_screen) {
+	return OSystem_MAC::create(gfx_mode, full_screen);
+}
+
+void OSystem_MAC::set_palette(const byte *colors, uint start, uint num) {
+	const byte *b = colors;
+	
+	(*pal)->ctSeed = TickCount();
+	for(int i = start; i < num; i++, b += 4) {
+		(*pal)->ctTable[i].value = i;
+		(*pal)->ctTable[i].rgb.red = b[0]<<8;
+		(*pal)->ctTable[i].rgb.green = b[1]<<8;
+		(*pal)->ctTable[i].rgb.blue = b[2]<<8;
+	}
+	
+	CTabChanged(pal);
+	
+	if(_sai_func)
+		UpdateGWorld(&screenBuf, 16, &blit_rect, NULL, NULL, 0);
+	else
+		UpdateGWorld(&screenBuf, 8, &blit_rect, pal, NULL, 0);
+	
+	if(start < _palette_changed_first)
+		_palette_changed_first = start;
+	
+	if(start + num > _palette_changed_last)
+		_palette_changed_last = start + num;
+}
+
+void OSystem_MAC::load_gfx_mode() {
+	force_full = true;
+	scaling = 1;
+	_internal_scaling = 1;
+	_mode_flags = 0;
+	_sai_func = NULL;
+	
+	switch(_mode) {
+		case GFX_2XSAI:
+			_sai_func = _2xSaI;
+		break;
+		
+		case GFX_SUPER2XSAI:
+			_sai_func = Super2xSaI;
+		break;
+		
+		case GFX_SUPEREAGLE:
+			_sai_func = SuperEagle;
+		break;
+			
+		case GFX_ADVMAME2X:
+			_sai_func = AdvMame2x;
+		break;
+		
+		case GFX_DOUBLESIZE:
+			scaling = 2;
+			_internal_scaling = 2;
+			_mode_flags = DF_WANT_RECT_OPTIM;
+		break;
+	
+		case GFX_TRIPLESIZE:
+			if (_full_screen) {
+				warning("full screen in useless in triplesize mode, reverting to normal mode");
+				goto normal_mode;
+			}
+			scaling = 3;
+			_internal_scaling = 3;
+			_mode_flags = DF_WANT_RECT_OPTIM;		
+		break;
+	
+		case GFX_NORMAL:
+	normal_mode:;
+			_mode_flags = DF_WANT_RECT_OPTIM;		
+		break;
+	
+	}
+	
+	if(_sai_func)
+	{		
+		_mode_flags = DF_WANT_RECT_OPTIM | DF_SEPARATE_TEMPSCREEN | DF_UPDATE_EXPAND_1_PIXEL;
+
+		Init_2xSaI(565);
+		_tmp_buf = (int16*)calloc((SCREEN_WIDTH+3)*(SCREEN_HEIGHT+3), sizeof(int16));
+		
+		scaling = 2;
+	}
+	else
+	{
+		switch(scaling) {
+		case 3:
+			_sai_func = Normal3x;
+			break;
+		case 2:
+			_sai_func = Normal2x;
+			break;
+		case 1:
+			_sai_func = Normal1x;
+			break;
+		}
+
+		_mode_flags = DF_WANT_RECT_OPTIM | DF_REAL_8BIT;
+	}
+	
+	set_scaling();
+}
+
+void OSystem_MAC::unload_gfx_mode() {
+	//warning("STUB: unload_gfx_mode()");		/* FIXME: Must free data here */
+	
+}
+
+void OSystem_MAC::init_size(uint w, uint h) {
+	//if (w != SCREEN_WIDTH && h != SCREEN_HEIGHT)
+	//	error("320x200 is the only game resolution supported");
+	
+	SCREEN_WIDTH = w;
+	SCREEN_HEIGHT = h;
+	CKSUM_NUM = (SCREEN_WIDTH * SCREEN_HEIGHT / (8*8));
+	dirty_rect_list = (Rect*)calloc(NUM_DIRTY_RECT, sizeof(Rect));
+	_ms_backup = (byte*)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING);
+	dirty_checksums = (uint32*)calloc(CKSUM_NUM*2, sizeof(uint32));
+
+	load_gfx_mode();
+}
+
+void OSystem_MAC::copy_rect(const byte *buf, int pitch, int x, int y, int w, int h) {
+	if (pitch == SCREEN_WIDTH && x==0 && y==0 && w==SCREEN_WIDTH && h==SCREEN_HEIGHT && _mode_flags&DF_WANT_RECT_OPTIM) {
+		/* Special, optimized case for full screen updates.
+		 * It tries to determine what areas were actually changed,
+		 * and just updates those, on the actual display. */
+		add_dirty_rgn_auto(buf);
+	} else {
+		/* Clip the coordinates */
+		if (x < 0) { w+=x; buf-=x; x = 0; }
+
+	if (y < 0) { h+=y; buf-=y*pitch; y = 0; }
+		if (w >= SCREEN_WIDTH-x) { w = SCREEN_WIDTH - x; }
+		if (h >= SCREEN_HEIGHT-y) { h = SCREEN_HEIGHT - y; }
+			
+		if (w<=0 || h<=0)
+			return;
+
+		cksum_valid = false;
+		add_dirty_rect(x, y, w, h);
+	}
+
+	/* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
+	if (_mouse_drawn)
+		undraw_mouse();
+	
+	byte *dst = (byte*)buf + y * SCREEN_WIDTH + x;
+	do {
+		memcpy(dst, buf, w);
+		dst += SCREEN_WIDTH;
+		buf += pitch;
+	} while(--h);
+}
+
+void OSystem_MAC::add_dirty_rect(int x, int y, int w, int h) {
+	if (force_full)
+		return;
+
+	if (num_dirty_rects == NUM_DIRTY_RECT)
+		force_full = true;
+	else {
+		Rect *r = &dirty_rect_list[num_dirty_rects++];
+		
+		/* Update the dirty region by 1 pixel for graphics drivers
+		 * that "smear" the screen */
+		if (_mode_flags & DF_UPDATE_EXPAND_1_PIXEL) {
+			x--;
+			y--;
+			w+=2;
+			h+=2;
+		}
+
+		/* clip */
+		if (x<0) { w+=x; x=0; }
+		if (y<0) { h+=y; y=0; }
+		if (w>=SCREEN_WIDTH-x) { w=SCREEN_WIDTH-x; }
+		if (h>=SCREEN_HEIGHT-y) { h=SCREEN_HEIGHT-y; }
+	
+		if (_internal_scaling != 1) {
+			x *= _internal_scaling;
+			y *= _internal_scaling;
+			w *= _internal_scaling;
+			h *= _internal_scaling;
+		}
+
+		r->left = x;
+		r->top = y;
+		r->right = x + w;
+		r->bottom = y + h;
+	}
+}
+
+#define ROL(a,n) a = (a<<(n)) | (a>>(32-(n)))
+#define DOLINE(x) a ^= ((uint32*)buf)[0+(x)*(SCREEN_WIDTH/4)]; b ^= ((uint32*)buf)[1+(x)*(SCREEN_WIDTH/4)]
+void OSystem_MAC::mk_checksums(const byte *buf) {
+	uint32 *sums = dirty_checksums;
+	uint x,y;
+
+	/* the 8x8 blocks in buf are enumerated starting in the top left corner and
+	 * reading each line at a time from left to right */
+	for(y=0; y!=SCREEN_HEIGHT/8; y++,buf+=SCREEN_WIDTH*(8-1))
+		for(x=0; x!=SCREEN_WIDTH/8; x++,buf+=8) {
+			uint32 a = x;
+			uint32 b = y;
+
+			DOLINE(0); ROL(a,13); ROL(b,11);
+			DOLINE(2); ROL(a,13); ROL(b,11);
+			DOLINE(4); ROL(a,13); ROL(b,11);
+			DOLINE(6); ROL(a,13); ROL(b,11);
+
+			a*=0xDEADBEEF;
+			b*=0xBAADF00D;
+
+			DOLINE(1); ROL(a,13); ROL(b,11);
+			DOLINE(3); ROL(a,13); ROL(b,11);
+			DOLINE(5); ROL(a,13); ROL(b,11);
+			DOLINE(7); ROL(a,13); ROL(b,11);
+
+			/* output the checksum for this block */
+			*sums++=a+b;
+		}
+}
+#undef DOLINE
+#undef ROL
+
+
+void OSystem_MAC::add_dirty_rgn_auto(const byte *buf) {
+	assert( ((uint32)buf & 3) == 0);
+	
+	/* generate a table of the checksums */
+	mk_checksums(buf);
+
+if (!cksum_valid) {
+		force_full = true;
+		cksum_valid = true;
+	}
+
+	/* go through the checksum list, compare it with the previous checksums,
+	 and add all dirty rectangles to a list. try to combine small rectangles
+		 into bigger ones in a simple way */
+	if (!force_full) {
+		uint x,y,w;
+		uint32 *ck = dirty_checksums;
+
+		for(y=0; y!=SCREEN_HEIGHT/8; y++) {
+			for(x=0; x!=SCREEN_WIDTH/8; x++,ck++) {
+				if (ck[0] != ck[CKSUM_NUM]) {
+					/* found a dirty 8x8 block, now go as far to the right as possible,
+						 and at the same time, unmark the dirty status by setting old to new. */
+					w=0;
+					do {
+						ck[w+CKSUM_NUM] = ck[w];
+						w++;
+					} while (x+w != SCREEN_WIDTH/8 && ck[w] != ck[w+CKSUM_NUM]);
+
+					add_dirty_rect(x*8, y*8, w*8, 8);
+
+					if (force_full)
+						goto get_out;
+				}
+			}
+		}
+	} else {
+		get_out:;
+		/* Copy old checksums to new */
+		memcpy(dirty_checksums + CKSUM_NUM, dirty_checksums, CKSUM_NUM * sizeof(uint32));
+	}
+}
+
+void OSystem_MAC::update_screen() {
+#if 0
+	/* First make sure the mouse is drawn, if it should be drawn. */
+	draw_mouse();
+
+	if (_palette_changed_last != 0) {
+		//warning("MAC: Palette should be uploaded!");/* FIXME: Add Palette changing code */
+		
+		/*GDevice **odisplay;
+		odisplay = GetGDevice();
+		SetGDevice(GetMainDevice());
+		SetEntries(0, (**pal).ctSize, (ColorSpec *)&(**pal).ctTable);
+		SetGDevice(odisplay);*/
+		
+		/*_palette_changed_last = 0;
+		if (_mode_flags & DF_FORCE_FULL_ON_PALETTE)
+			*/force_full = true;
+	}
+
+	/* force a full redraw, accomplish that by adding one big rect to the dirty
+	 * rect list */
+	if (force_full) {
+		num_dirty_rects = 1;
+		
+		dirty_rect_list[0].left = 0;
+		dirty_rect_list[0].top = 0;
+		dirty_rect_list[0].right = SCREEN_WIDTH;
+		dirty_rect_list[0].bottom = SCREEN_HEIGHT;
+	}
+	
+	if (num_dirty_rects > 0)
+	{
+		Rect *r; 
+		uint32 srcPitch, dstPitch;
+		Rect *last_rect = dirty_rect_list + num_dirty_rects;
+	
+		/* Convert appropriate parts of the image into 16bpp */
+		if ((_mode_flags & DF_REAL_8BIT) == 0) {
+			Rect dst;
+			for(r=dirty_rect_list; r!=last_rect; ++r) {
+				dst = *r;
+				dst.left++;
+				dst.top++;
+				dst.right++;
+				dst.bottom++;
+			}
+		}
+	
+		/*srcPitch = sdl_tmpscreen->pitch;
+		dstPitch = sdl_hwscreen->pitch;*/
+	
+		if ((_mode_flags & DF_REAL_8BIT) == 0) {
+			for(r=dirty_rect_list; r!=last_rect; ++r) {
+				register int dst_y = r->y + _current_shake_pos;
+				register int dst_h = 0;
+				if (dst_y < SCREEN_HEIGHT) {
+					dst_h = r->h;
+					if (dst_h > SCREEN_HEIGHT - dst_y)
+						dst_h = SCREEN_HEIGHT - dst_y;
+					
+					r->x <<= 1;
+					dst_y <<= 1;
+					
+					_sai_func((byte*)sdl_tmpscreen->pixels + (r->x+2) + (r->y+1)*srcPitch, srcPitch, NULL, 
+						(byte*)sdl_hwscreen->pixels + r->x*scaling + dst_y*dstPitch, dstPitch, r->w, dst_h);
+				}
+				
+				r->y = dst_y;
+				r->w <<= 1;
+				r->h = dst_h << 1;
+			}
+		} else {
+			for(r=dirty_rect_list; r!=last_rect; ++r) {
+				register int dst_y = r->y + _current_shake_pos;
+				register int dst_h = 0;
+				if (dst_y < SCREEN_HEIGHT) {
+					dst_h = r->h;
+					if (dst_h > SCREEN_HEIGHT - dst_y)
+						dst_h = SCREEN_HEIGHT - dst_y;
+					
+					dst_y *= scaling;
+					
+					_sai_func((byte*)sdl_tmpscreen->pixels + r->x + r->y*srcPitch, srcPitch, NULL, 
+						(byte*)sdl_hwscreen->pixels + r->x*scaling + dst_y*dstPitch, dstPitch, r->w, dst_h);
+				}
+				
+				r->x *= scaling;
+				r->y = dst_y;
+				r->w *= scaling;
+				r->h = dst_h * scaling;
+			}
+		}
+	
+		if (force_full) {
+			dirty_rect_list[0].y = 0;
+			dirty_rect_list[0].h = SCREEN_HEIGHT * scaling;
+		}
+	}
+		
+	/*if(_mode_flags & DF_2xSAI)
+	{
+		Rect *r;
+		uint32 area = 0;
+		
+		Rect *dr = dirty_rect_list + num_dirty_rects;
+		
+		for(r = dirty_rect_list; r != dr; r++)
+		{
+			GWorldPtr gw;
+			Rect rec;
+			SetRect(&rec, 0, 0, 320, 200);
+			NewGWorldFromPtr(&gw, 16, &rec, NULL, NULL, 0, (char*)_tmp_buf, rec.right);
+			CopyBits(GetPortBitMapForCopyBits(gw), GetPortBitMapForCopyBits(screenBuf),
+						r, r, srcCopy, 0L);
+		}
+		
+		for(r = dirty_rect_list; r != dr; r++)
+		{
+			_sai_func((byte*)_tmp_buf + r->left * 2 + r->top * 640, 640, NULL,
+				(byte*)_sai_buf + r->left * 4 + r->top * 640 * 4, 640 * 2,
+				r->right - r->left, r->bottom - r->top);
+			
+			area += (r->right - r->left) * (r->bottom - r->top);
+			
+			r->left <<= 1;
+			r->right <<= 1;
+			r->top <<= 1;
+			r->bottom <<= 1;
+		}
+	}*/
+	
+	update_rects();
+	//blit_to_screen();
+	
+	num_dirty_rects = 0;
+
+#endif
+}
+
+bool OSystem_MAC::show_mouse(bool visible) {
+	if (_mouse_visible == visible)
+		return visible;
+	
+	bool last = _mouse_visible;
+	_mouse_visible = visible;
+
+	if (visible)
+		draw_mouse();
+	else
+		undraw_mouse();
+
+	return last;
+}
+	
+void OSystem_MAC::set_mouse_pos(int x, int y) {
+	if (x != _ms_cur.x || y != _ms_cur.y) {
+		_ms_cur.x = x;
+		_ms_cur.y = y;
+		undraw_mouse();
+	}
+}
+	
+void OSystem_MAC::set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y) {
+	_ms_cur.w = w;
+	_ms_cur.h = h;
+
+	_ms_hotspot_x = hotspot_x;
+	_ms_hotspot_y = hotspot_y;
+
+	_ms_buf = (byte*)buf;
+
+	undraw_mouse();
+}
+	
+void OSystem_MAC::set_shake_pos(int shake_pos) {
+	/*int old_shake_pos = _current_shake_pos;
+	int dirty_height, dirty_blackheight;
+	int dirty_top, dirty_blacktop;
+	
+	if (shake_pos != old_shake_pos) {
+		_current_shake_pos = shake_pos;
+		force_full = true;
+
+		/* Old shake pos was current_shake_pos, new is shake_pos.
+		 * Move the screen up or down to account for the change.
+		 */
+		//SDL_Rect dstr = { 0, shake_pos*scaling, 320*scaling, 200*scaling };
+		//SDL_Rect srcr = { 0, old_shake_pos*scaling, 320*scaling, 200*scaling };
+		//SDL_BlitSurface(sdl_screen, &srcr, sdl_screen, &dstr);
+	/*	Rect srcr, dstr;
+		
+		SetRect(&srcr, 0, old_shake_pos * scaling, 320 * scaling, 200 * scaling);
+		SetRect(&dstr, 0, shake_pos * scaling, 320 * scaling, 200 * scaling);
+		
+		CopyBits(GetPortBitMapForCopyBits(screenBuf), GetPortBitMapForCopyBits(GetWindowPort(wref)),
+			&srcr, &dstr, srcCopy, 0L);
+		
+		/* Refresh either the upper part of the screen,
+		 * or the lower part */
+	/*	if (shake_pos > old_shake_pos) {
+			dirty_height = MIN(shake_pos, 0) - MIN(old_shake_pos, 0);
+			dirty_top = -MIN(shake_pos, 0);
+			dirty_blackheight = MAX(shake_pos, 0) - MAX(old_shake_pos, 0);
+			dirty_blacktop = MAX(old_shake_pos, 0);
+		} else {
+			dirty_height = MAX(old_shake_pos, 0) - MAX(shake_pos, 0);
+			dirty_top = 200 - MAX(old_shake_pos, 0);
+			dirty_blackheight = MIN(old_shake_pos, 0) - MIN(shake_pos, 0);
+			dirty_blacktop = 200 + MIN(shake_pos, 0);
+		}
+
+		/* Fill the dirty area with blackness or the scumm image */
+		//SDL_Rect blackrect = {0, dirty_blacktop*scaling, 320*scaling, dirty_blackheight*scaling};
+		//SDL_FillRect(sdl_screen, &blackrect, 0);
+
+		/* FIXME: Um, screen seems to glitch since this
+		          'not needed' function was removed */
+		//g_scumm->redrawLines(dirty_top, dirty_top + dirty_height);
+/*	}*/
+}
+		
+uint32 OSystem_MAC::get_msecs() {
+	UnsignedWide ms;
+
+	Microseconds(&ms);
+	return(ms.lo / 1000);
+}
+	
+void OSystem_MAC::delay_msecs(uint msecs) {
+	uint32 start = get_msecs();
+	Event dummy;
+
+	do {
+		poll_event(&dummy);	/* Do something to avoid CPU lock */
+		if(get_msecs() >= start + msecs)
+			break;
+	} while (1);
+}
+	
+void *OSystem_MAC::create_thread(ThreadProc *proc, void *param) {
+	warning("MAC: Stub create_thread()");
+	//NewThread(kCooperativeThread, (void*)proc, param, 0L, kCreateIfNeeded, NULL, NULL);
+}
+
+int mapKey(int key, byte code, byte mod)
+{
+	switch(code) {
+	case 0x35:
+		key = 27;
+	break;
+	case 0x31:
+		key = 32;
+	break;
+	case 0x60:
+		key = 601;
+	break;
+	}
+	
+	return key;
+}
+	
+bool OSystem_MAC::poll_event(Event *event)
+{
+	EventRef theEvent;
+	EventTargetRef theTarget;
+	OSStatus theErr;
+	
+	OSStatus		result = eventNotHandledErr;
+	HICommand		command;
+	Point			mouse;
+
+	theTarget = GetEventDispatcherTarget();
+	theErr = ReceiveNextEvent(GetEventTypeCount(kCmdEvents), kCmdEvents, kEventDurationNoWait,true, &theEvent);
+	
+	GetEventParameter( theEvent, kEventParamDirectObject, typeHICommand, NULL,
+		sizeof( HICommand ), NULL, &command );
+	
+	switch(GetEventClass(theEvent))
+	{
+		case kEventClassWindow:
+			switch(GetEventKind(theEvent))
+			{
+				case kEventWindowDrawContent:
+				break;
+				
+				case kEventWindowHandleContentClick:
+					EventMouseButton btn;
+					
+					GetEventParameter(theEvent, kEventParamMouseButton, typeMouseButton, NULL,
+						sizeof(EventMouseButton), NULL, &btn);
+					
+					if(btn == kEventMouseButtonPrimary)
+						event->event_code = EVENT_RBUTTONDOWN;
+					else if(btn == kEventMouseButtonSecondary)
+						event->event_code = EVENT_LBUTTONDOWN;
+					
+					debug(1, "Mouse down!");
+					
+					if(wref != FrontWindow())
+					{
+// FIXME - seems some versions of the CarbonLib stub are missing ActivateWindow
+//						ActivateWindow(wref, true);
+						BringToFront(wref);
+					}
+					return true;
+				break;
+				
+				case kEventWindowClose:
+					quit();
+				break;
+			}
+		break;
+		
+		case kEventClassCommand:
+			switch(command.commandID)
+			{
+				case kNewGameCmd:
+					
+				break;
+				
+				case kOpenGameCmd:
+					//scumm->_saveLoadSlot = 0;
+					//scumm->_saveLoadFlag = 2;
+				break;
+				
+				case kSaveGameCmd:
+					//scumm->_saveLoadSlot = 0;
+					//sprintf(scumm->_saveLoadName, "Quicksave %d", scumm->_saveLoadSlot);
+					//scumm->_saveLoadFlag = 1;
+				break;
+				
+				case kQuitCmd:
+					quit();
+				break;
+				
+				case kPrefsCmd:
+					//Preferences();
+				break;
+				
+				case kAboutCmd:
+					//About();
+				break;
+			}
+		break;
+		
+		case kEventClassKeyboard:
+			if(GetEventKind(theEvent) == kEventRawKeyDown)
+			{
+				char	key;
+				UInt32	mod, code;
+				
+				GetEventParameter(theEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &code);
+				GetEventParameter(theEvent, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &key);
+				GetEventParameter(theEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &mod);
+				
+				event->event_code = EVENT_KEYDOWN;
+				event->kbd.keycode = code;
+				event->kbd.ascii = mapKey(key, code, mod);
+				debug(1, "Key down: %c", event->kbd.ascii);
+				return true;
+			}
+		break;
+		
+		case kEventClassMouse:
+			EventMouseButton btn;
+			Rect winRect;
+			
+			switch(GetEventKind(theEvent))
+			{			
+				case kEventMouseDown:
+					WindowRef theWin;
+					
+					GetEventParameter(theEvent, kEventParamDirectObject, typeWindowRef, NULL, sizeof(WindowRef),
+						NULL, &theWin);
+					if(theWin != FrontWindow())
+					{
+// FIXME - seems some versions of the CarbonLib stub are missing ActivateWindow
+//						ActivateWindow(theWin, true);
+						BringToFront(theWin);
+					}
+					
+					GetEventParameter(theEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &mouse);
+					
+					GetWindowBounds(wref, kWindowContentRgn, &winRect);
+					if(PtInRect(mouse, &winRect))
+					{
+						GetEventParameter(theEvent, kEventParamMouseButton, typeMouseButton, NULL,
+							sizeof(EventMouseButton), NULL, &btn);
+						
+						if(btn == kEventMouseButtonPrimary)
+							event->event_code = EVENT_RBUTTONDOWN;
+						else if(btn == kEventMouseButtonSecondary)
+							event->event_code = EVENT_LBUTTONDOWN;
+						
+						debug(1, "Mouse down!");
+					}				
+				break;
+				
+				case kEventMouseUp:
+					
+					GetEventParameter(theEvent, kEventParamMouseButton, typeMouseButton, NULL,
+						sizeof(EventMouseButton), NULL, &btn);
+					
+					if(btn == kEventMouseButtonPrimary)
+						event->event_code = EVENT_RBUTTONUP;
+					else if(btn == kEventMouseButtonSecondary)
+						event->event_code = EVENT_LBUTTONUP;
+					
+					debug(1, "Mouse up!");
+					
+					return true;
+				break;
+				
+				case kEventMouseMoved:				
+					GetEventParameter(theEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &mouse);
+					
+					GetWindowBounds(wref, kWindowContentRgn, &winRect);
+					if(PtInRect(mouse, &winRect))
+					{
+						CGrafPtr oldPort;
+					
+						GetPort(&oldPort);
+						SetPortWindowPort(wref);
+						GlobalToLocal(&mouse);
+						
+						event->event_code = EVENT_MOUSEMOVE;
+						event->mouse.x = mouse.h / scaling;
+						event->mouse.y = mouse.v / scaling;
+						
+						//scumm->mouse.x = mouse.h/wm->scale;
+						//scumm->mouse.y = mouse.v/wm->scale;
+					}
+					Point offset = {0, 0};
+					ShieldCursor(&winRect, offset);
+					return true;
+				break;
+			}
+		break;
+	}
+	
+	if(theErr == noErr && theEvent != NULL) {
+		SendEventToEventTarget (theEvent, theTarget);
+		ReleaseEvent(theEvent);
+	}
+}
+
+pascal void sound_callback(SndChannel *chan, SndCommand *cmd_passed)
+{
+	OSystem_MAC* syst = (OSystem_MAC*)chan->userInfo;
+	syst->sound_callback(chan, cmd_passed);
+}
+
+void OSystem_MAC::sound_callback(SndChannel *chan, SndCommand *cmd_passed)
+{
+	UInt32 fill_me, play_me;
+	SndCommand cmd;
+	
+	fill_me = cmd_passed->param2;
+	play_me = ! fill_me;
+	
+	header.samplePtr = (Ptr)buffer[play_me];
+	
+	cmd.cmd = bufferCmd;
+	cmd.param1 = 0;
+	cmd.param2 = (long)&header;
+	
+	SndDoCommand(chan, &cmd, 0);
+	
+	memset(buffer[fill_me], 0, size);
+	//sndProc(parameter, buffer[fill_me], size);
+	//SoundMixer::on_generate_samples(parameter, buffer[fill_me], size);
+	
+	cmd.cmd = callBackCmd;
+	cmd.param1 = 0;
+	cmd.param2 = play_me;
+	
+	SndDoCommand(chan, &cmd, 0);
+}
+
+bool OSystem_MAC::set_sound_proc(void *param, SoundProc *proc, byte format)
+{
+	SndCallBackUPP callback;
+	int sample_size;
+		
+	memset(&header, 0, sizeof(header));
+	callback = NewSndCallBackUPP(::sound_callback);
+	size = ((0x9010 & 0xFF) / 8) * 2048;
+	sample_size = size / 2048 * 8;
+	header.numChannels = 1;
+	header.sampleSize = sample_size;
+	header.sampleRate = SAMPLES_PER_SEC << 16;
+	header.numFrames = 	2048;
+	header.encode = cmpSH;
+	
+	for(int i = 0; i < 2; i++)
+	{
+		buffer[i] = (UInt8*)malloc(sizeof(UInt8) * size);
+		memset(buffer[i], 0, size);
+	}
+	
+	channel = (SndChannelPtr)malloc(sizeof(*channel));
+	channel->qLength = 128;
+	channel->userInfo = (long)this;
+	SndNewChannel(&channel, sampledSynth, initMono, callback);
+	
+	SndCommand cmd;
+	cmd.cmd = callBackCmd;
+	cmd.param2 = 0;
+	SndDoCommand(channel, &cmd, 0);
+	
+	sndProc = proc;
+	parameter = param;
+
+	return true;
+}
+
+
+/* retrieve the 320x200 bitmap currently being displayed */
+void OSystem_MAC::get_320x200_image(byte *buf)
+{
+	/* make sure the mouse is gone */
+	undraw_mouse();
+	
+	byte *src;
+	int x,y;
+
+	switch(_internal_scaling) {
+	case 1:
+		memcpy(buf, _gfx_buf, 320*200);
+		break;
+
+	case 2:
+		src = (byte*)_gfx_buf;
+		for(y=0; y!=200; y++) {
+			for(x=0; x!=320; x++)
+				buf[x] = src[x*2];
+			buf += 320;
+			src += 320 * 2 * 2;
+		}
+		break;
+
+	case 3:
+		src = (byte*)_gfx_buf;
+		for(y=0; y!=200; y++) {
+			for(x=0; x!=320; x++)
+				buf[x] = src[x*3];
+			buf += 320;
+			src += 320 * 3 * 3;
+		}
+		break;
+	}	
+}
+
+void OSystem_MAC::hotswap_gfx_mode()
+{
+	/* hmm, need to allocate a 320x200 bitmap
+	 * which will contain the "backup" of the screen during the change.
+	 * then draw that to the new screen right after it's setup.
+	 */
+	
+	byte *bak_mem = (byte*)malloc(320*200);
+
+	get_320x200_image(bak_mem);
+
+	unload_gfx_mode();
+	load_gfx_mode();
+
+	force_full = true;
+
+	/* reset palette ? */
+	pal = (CTabHandle)NewHandleClear(sizeof(ColorTable) + 255 * sizeof(ColorSpec));
+	(*pal)->ctFlags = 0;
+	(*pal)->ctSize = 255;
+	
+	/* blit image */
+	copy_rect(bak_mem, 320, 0, 0, 320, 200);
+	free(bak_mem);
+
+	update_screen();
+}
+
+uint32 OSystem_MAC::property(int param, Property *value) {
+	switch(param) {
+	case PROP_TOGGLE_FULLSCREEN:
+		_full_screen ^= true;
+	return 1;
+
+	case PROP_SET_WINDOW_CAPTION:
+		StringPtr gameText = CToPascal((char*)value->caption);
+		SetWTitle(wref, gameText);
+	return 1;
+
+	case PROP_OPEN_CD:
+	break;
+
+	case PROP_SET_GFX_MODE:
+		if(value->gfx_mode >= 7)
+			return 0;
+		_mode = value->gfx_mode;
+		hotswap_gfx_mode();
+	return 1;
+
+
+	case PROP_SHOW_DEFAULT_CURSOR:
+	break;
+	
+	case PROP_GET_SAMPLE_RATE:
+	return SAMPLES_PER_SEC;
+	break;
+	}
+	
+	return 0;
+}
+		
+void OSystem_MAC::quit() {
+	unload_gfx_mode();
+
+	QuitApplicationEventLoop();
+	ExitToShell();
+}
+
+void OSystem_MAC::draw_mouse() {
+	if (_mouse_drawn || !_mouse_visible)
+		return;
+	_mouse_drawn = true;
+	
+	const int ydraw = _ms_cur.y + _current_shake_pos - _ms_hotspot_y;
+	const int xdraw = _ms_cur.x - _ms_hotspot_x;
+	const int w = _ms_cur.w;
+	const int h = _ms_cur.h;
+	int x,y;
+	byte color;
+	byte *dst, *bak = _ms_backup;
+	byte *buf = _ms_buf;
+
+	_ms_old.w = w;
+	_ms_old.h = h;
+	_ms_old.x = xdraw;
+	_ms_old.y = ydraw;
+	
+	byte *src;
+	if(_sai_func)
+		src = (byte*)_tmp_buf;
+	else
+		src = _gfx_buf;
+	
+	switch(_internal_scaling) {
+	case 1:
+		dst = (byte *)src + ydraw * 320 + xdraw;
+
+		for (y = 0; y < h; y++, dst += 320, bak += MAX_MOUSE_W, buf += w) {
+			if ((uint) (ydraw + y) < 200) {
+				for (x = 0; x < w; x++) {
+					if ((uint) (xdraw + x) < 320) {
+						bak[x] = dst[x];
+						if ((color = buf[x]) != 0xFF) {
+							dst[x] = color;
+						}
+					}
+				}
+			}
+		}
+		break;
+
+	case 2:
+		dst = (byte *)src + ydraw * 640 * 2 + xdraw * 2;
+
+		for (y = 0; y < h; y++, dst += 640 * 2, bak += MAX_MOUSE_W * 2, buf += w) {
+			if ((uint) (ydraw + y) < 200) {
+				for (x = 0; x < w; x++) {
+					if ((uint) (xdraw + x) < 320) {
+						bak[x * 2] = dst[x * 2];
+						bak[x * 2 + 1] = dst[x * 2 + 1];
+						if ((color = buf[x]) != 0xFF) {
+							dst[x * 2] = color;
+							dst[x * 2 + 1] = color;
+							dst[x * 2 + 640] = color;
+							dst[x * 2 + 1 + 640] = color;
+						}
+					}
+				}
+			}
+		}
+		break;
+
+	case 3:
+		dst = (byte *)src + ydraw * 960 * 3 + xdraw * 3;
+
+		for (y = 0; y < h; y++, dst += 960 * 3, bak += MAX_MOUSE_W * 3, buf += w) {
+			if ((uint) (ydraw + y) < 200) {
+				for (x = 0; x < w; x++) {
+					if ((uint) (xdraw + x) < 320) {
+						bak[x * 3] = dst[x * 3];
+						bak[x * 3 + 1] = dst[x * 3 + 1];
+						bak[x * 3 + 2] = dst[x * 3 + 2];
+						if ((color = buf[x]) != 0xFF) {
+							dst[x * 3] = color;
+							dst[x * 3 + 1] = color;
+							dst[x * 3 + 2] = color;
+							dst[x * 3 + 960] = color;
+							dst[x * 3 + 1 + 960] = color;
+							dst[x * 3 + 2 + 960] = color;
+							dst[x * 3 + 960 + 960] = color;
+							dst[x * 3 + 1 + 960 + 960] = color;
+							dst[x * 3 + 2 + 960 + 960] = color;
+						}
+					}
+				}
+			}
+		}
+		break;
+	}
+
+	add_dirty_rect(xdraw,ydraw,w,h);
+}
+
+void OSystem_MAC::undraw_mouse() {
+	if (!_mouse_drawn)
+		return;
+	_mouse_drawn = false;
+	
+	byte *dst, *bak = _ms_backup;
+	byte *src;
+	const int old_mouse_x = _ms_old.x;
+	const int old_mouse_y = _ms_old.y;
+	const int old_mouse_w = _ms_old.w;
+	const int old_mouse_h = _ms_old.h;
+	int x,y;
+	
+	if(_sai_func)
+		src = (byte*)_tmp_buf;
+	else
+		src = _gfx_buf;
+	
+	switch(_internal_scaling) {
+	case 1:
+		dst = (byte *)src + old_mouse_y * 320 + old_mouse_x;
+
+		for (y = 0; y < old_mouse_h; y++, bak += MAX_MOUSE_W, dst += 320) {
+			if ((uint) (old_mouse_y + y) < 200) {
+				for (x = 0; x < old_mouse_w; x++) {
+					if ((uint) (old_mouse_x + x) < 320) {
+						dst[x] = bak[x];
+					}
+				}
+			}
+		}
+		break;
+
+	case 2:
+		dst = (byte *)src + old_mouse_y * 640 * 2 + old_mouse_x * 2;
+
+		for (y = 0; y < old_mouse_h; y++, bak += MAX_MOUSE_W * 2, dst += 640 * 2) {
+			if ((uint) (old_mouse_y + y) < 200) {
+				for (x = 0; x < old_mouse_w; x++) {
+					if ((uint) (old_mouse_x + x) < 320) {
+						dst[x * 2 + 640] = dst[x * 2] = bak[x * 2];
+						dst[x * 2 + 640 + 1] = dst[x * 2 + 1] = bak[x * 2 + 1];
+					}
+				}
+			}
+		}
+		break;
+
+	case 3:
+		dst = (byte *)src + old_mouse_y * 960 * 3 + old_mouse_x * 3;
+
+		for (y = 0; y < old_mouse_h; y++, bak += MAX_MOUSE_W * 3, dst += 960 * 3) {
+			if ((uint) (old_mouse_y + y) < 200) {
+				for (x = 0; x < old_mouse_w; x++) {
+					if ((uint) (old_mouse_x + x) < 320) {
+						dst[x * 3 + 960] = dst[x * 3 + 960 + 960] = dst[x * 3] =
+							bak[x * 3];
+						dst[x * 3 + 960 + 1] = dst[x * 3 + 960 + 960 + 1] =
+							dst[x * 3 + 1] = bak[x * 3 + 1];
+						dst[x * 3 + 960 + 2] = dst[x * 3 + 960 + 960 + 2] =
+							dst[x * 3 + 2] = bak[x * 3 + 2];
+					}
+				}
+			}
+		}
+		break;
+	}
+
+	add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h);
+}
+
+void OSystem_MAC::stop_cdrom() {
+}
+
+void OSystem_MAC::play_cdrom(int track, int num_loops, int start_frame, int end_frame) {
+	/* Reset sync count */
+	g_scumm->_vars[g_scumm->VAR_MI1_TIMER] = 0;
+}
+
+bool OSystem_MAC::poll_cdrom() {
+}
+
+void OSystem_MAC::update_cdrom() {
+}
+
+
+
+/*************************************************************/
+/** Mac specific code ****************************************/
+void OSystem_MAC::set_scaling() {
+	Rect rectWin;
+	SetRect(&rectWin, 0, 0, 320 * scaling, 200 * scaling);
+	HideWindow(wref);
+	SetWindowBounds(wref, kWindowContentRgn, &rectWin);
+	RepositionWindow(wref, NULL, kWindowCenterOnMainScreen);
+	ShowWindow(wref);
+	blit_rect = rectWin;
+	
+	if(_sai_func)
+	{
+		Rect r;
+		
+		//SetRect(&r, 0, 0, 320, 240);
+		_sai_buf = (int16*)malloc((320 * 200) * 2 * sizeof(int16));		
+		
+		NewGWorldFromPtr(&screenBuf, 16, &blit_rect, NULL, nil, 0, (char *)_sai_buf, blit_rect.right);
+	}
+	else
+	{
+		_gfx_buf = (byte*)malloc((320 * 200) * scaling * sizeof(byte));
+		NewGWorldFromPtr(&screenBuf, 8, &blit_rect, pal, nil, 0, (char *)_gfx_buf, blit_rect.right);
+	}	
+	
+	//NewGWorldFromPtr(&screenBuf, 8, &blit_rect, pal, nil, 0, (char *)_gfx_buf, blit_rect.right);
+	
+	//if(screenBuf != NULL)
+	//	UpdateGWorld(&screenBuf, 8, &blit_rect, pal, NULL, NULL);
+}
+
+void OSystem_MAC::blit_to_screen()
+{
+	CopyBits(GetPortBitMapForCopyBits(screenBuf),
+	GetPortBitMapForCopyBits(GetWindowPort(wref)), &blit_rect, &blit_rect, srcCopy, 0L);
+}
+
+void OSystem_MAC::init_mac_stuff()
+{
+	Rect			rectWin;
+
+	
+	MenuRef AppleMenu = GetMenu(1000);
+	InsertMenu(AppleMenu, 0);
+	SetMenuItemCommandID(AppleMenu, 1, kAboutCmd);
+	MenuRef FileMenu = GetMenu(1001);
+	SetMenuItemCommandID(FileMenu, 1, kNewGameCmd);
+	SetMenuItemCommandID(FileMenu, 2, kOpenGameCmd);
+	SetMenuItemCommandID(FileMenu, 3, kSaveGameCmd);
+	SetMenuItemCommandID(FileMenu, 5, kQuitCmd);
+	DeleteMenuItems(FileMenu, CountMenuItems(FileMenu)-1, 2);
+	InsertMenu(FileMenu, 0);
+	MenuRef windMenu;
+	CreateStandardWindowMenu(0, &windMenu);
+	InsertMenu(windMenu, 0);
+	EnableMenuCommand(NULL, kPrefsCmd);
+	DrawMenuBar();
+	
+	SetRect(&rectWin, 0, 0, 320, 200);
+	UInt32 WinAttrib = (kWindowCloseBoxAttribute | kWindowCollapseBoxAttribute |
+				kWindowInWindowMenuAttribute | kWindowStandardHandlerAttribute);
+	
+	if(noErr != CreateNewWindow(kDocumentWindowClass, WinAttrib, &rectWin, &wref))
+	{
+		//Error("Couldn't create Window!");
+	}
+	
+	RepositionWindow(wref, NULL, kWindowCenterOnMainScreen);
+	
+	Str255 WindowTitle = "\pScummVM";
+	SetWTitle(wref, WindowTitle);
+	
+	SetPortWindowPort(wref);
+	//ShowWindow(wref);
+	
+	InstallStandardEventHandler(GetWindowEventTarget(wref));
+	
+	//OSStatus err = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, NewAEEventHandlerUPP(QuitEventHandler), 0L, false);
+	
+	blit_rect = rectWin;
+	pal = (CTabHandle)NewHandleClear(sizeof(ColorTable) + 255 * sizeof(ColorSpec));
+	(*pal)->ctFlags = 0;
+	(*pal)->ctSize = 255;
+	//NewGWorld(&screenBuf, 8, &blit_rect, 0, 0, 0);
+}
+
+void OSystem_MAC::update_rects()
+{
+	for(int i = 0; i < num_dirty_rects; i++)
+	{
+		Rect rec = dirty_rect_list[i];
+		
+		CopyBits(GetPortBitMapForCopyBits(screenBuf),
+				GetPortBitMapForCopyBits(GetWindowPort(wref)),
+				&rec, &rec, srcCopy, 0L);
+	}
+}
diff --git a/backends/mac/macos.h b/backends/mac/macos.h
new file mode 100644
index 0000000000..09c40456e9
--- /dev/null
+++ b/backends/mac/macos.h
@@ -0,0 +1,24 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ *
+ *
+ */
+ 
+ //#define MACOS_SDL
+ #define MACOS_CARBON
+ 
\ No newline at end of file
diff --git a/backends/mac/scummvm.icns b/backends/mac/scummvm.icns
new file mode 100644
index 0000000000..5f5e10d732
--- /dev/null
+++ b/backends/mac/scummvm.icns
diff --git a/backends/mac/scummvm.mcp b/backends/mac/scummvm.mcp
new file mode 100644
index 0000000000..41a29050f4
--- /dev/null
+++ b/backends/mac/scummvm.mcp
diff --git a/backends/morphos/Makefile b/backends/morphos/Makefile
new file mode 100644
index 0000000000..00fd3992d1
--- /dev/null
+++ b/backends/morphos/Makefile
@@ -0,0 +1,48 @@
+vpath %.cpp ../:../sound/:../v3/:../v4/:../simon/:../gui/
+vpath %.h   ../
+
+CC      = g++
+CFLAGS  = -Wno-multichar -fstrength-reduce -fno-rtti -O2
+DEFINES = -DNO_PPCINLINE_STDARG -DNO_PPCINLINE_VARARGS
+LDFLAGS := -noixemul -s
+INCLUDES:= -I../ -I../sound
+CPPFLAGS= $(DEFINES) $(INCLUDES)
+LIBS	= -lamiga -lamigastubs -lcdda
+ZIPFILE := scummvm-`date '+%Y-%m-%d'`.zip
+
+INCS	= scumm.h scummsys.h stdafx.h
+
+GUIOBJS = widget.o dialog.o newgui.o ListWidget.o ScrollBarWidget.o
+
+SIMONOBJS =	midi.o simon.o simondebug.o simonitems.o simonres.o simonsys.o simonverb.o simonvga.o
+
+OBJS	= actor.o akos.o boxes.o config-file.o costume.o gfx.o object.o resource.o \
+	saveload.o script.o scummvm.o sound.o string.o sys.o verbs.o \
+	morphos.o morphos_scaler.o morphos_sound.o morphos_start.o morphos_timer.o \
+	script_v1.o script_v2.o debug.o gui.o imuse.o fmopl.o mixer.o mididrv.o \
+	debugrl.o vars.o insane.o gameDetector.o resource_v3.o resource_v4.o \
+	util.o main.o bundle.o $(GUIOBJS) $(SIMONOBJS)
+
+DISTFILES=$(OBJS:.o=.cpp) Makefile scumm.h scummsys.h stdafx.h stdafx.cpp \
+	windows.cpp debugrl.h whatsnew.txt readme.txt copying.txt \
+	scummvm.dsp scummvm.dsw sound/fmopl.h
+
+.cpp.o:
+	$(CC) $(CFLAGS) $(CPPFLAGS) -c $(<) -o $*.o
+
+all: scummvm
+
+scummvm: $(OBJS)
+	$(CC) $(LDFLAGS) -o $(@) $(OBJS) $(LIBS)
+
+#$(OBJS): Makefile
+
+clean:
+	rm -f $(OBJS) scummvm
+
+dist:
+	rm -f $(ZIPFILE)
+	zip -q $(ZIPFILE) $(DISTFILES)
+
+check:
+$(OBJS): $(INCS)
diff --git a/backends/morphos/MorphOS.readme b/backends/morphos/MorphOS.readme
new file mode 100644
index 0000000000..693ae324c4
--- /dev/null
+++ b/backends/morphos/MorphOS.readme
@@ -0,0 +1,13 @@
+This directory contains the source for the MorphOS port of ScummVM. To build, you
+must have a proper Geek Gadgets installation. Just type "make" in the MorphOS
+subdirectory. If you don't have the includes for AMidi 2 and cdda.library, check
+my webpage. If they aren't uploaded yet, feel free to e-mail me.
+
+You don't have to build ScummVM yourself. The latest official and CVS binaries are
+available from my website at:
+
+http://www.muenster.de/~tomjoad/scummvm.html
+
+Ruediger Hanke
+tomjoad@muenster.de
+
diff --git a/backends/morphos/morphos.cpp b/backends/morphos/morphos.cpp
new file mode 100644
index 0000000000..a949cbfd2f
--- /dev/null
+++ b/backends/morphos/morphos.cpp
@@ -0,0 +1,1293 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2002 Rüdiger Hanke
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * MorphOS interface
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "scumm.h"
+
+#include <exec/types.h>
+#include <exec/memory.h>
+#include <exec/libraries.h>
+#include <exec/semaphores.h>
+#include <devices/ahi.h>
+#include <dos/dostags.h>
+#include <intuition/screens.h>
+#include <cybergraphics/cybergraphics.h>
+#include <devices/inputevent.h>
+#include <intuition/intuition.h>
+
+#include <clib/alib_protos.h>
+#include <proto/exec.h>
+#include <proto/dos.h>
+#include <proto/graphics.h>
+#include <proto/intuition.h>
+#include <proto/keymap.h>
+#include <proto/timer.h>
+#include <proto/cdda.h>
+#include <proto/cybergraphics.h>
+
+#include <emul/emulinterface.h>
+
+#include <time.h>
+
+#include "morphos.h"
+#include "morphos_scaler.h"
+
+static TagItem FindCDTags[] = { { CDFA_VolumeName, 0 },
+										  { TAG_DONE,        0 }
+										};
+static TagItem PlayTags[] =   { { CDPA_StartTrack, 1 },
+										  { CDPA_StartFrame, 0 },
+										  { CDPA_EndTrack,   1 },
+										  { CDPA_EndFrame,   0 },
+										  { CDPA_Loops,      1 },
+										  { TAG_DONE,		   0 }
+										};
+
+TagItem musicProcTags[] = { { NP_Entry,       0							       	  },
+									 { NP_Name,        (ULONG)"ScummVM Music Thread"  },
+									 { NP_Priority,    0  							        },
+									 {	TAG_DONE,       0 					       		  }
+								  };
+TagItem soundProcTags[] = { { NP_Entry,       0							       	  },
+									 { NP_Name,        (ULONG)"ScummVM Sound Thread"  },
+									 { NP_Priority,    0  							        },
+									 { TAG_DONE,       0 					       		  }
+								  };
+
+#define BLOCKSIZE_X	32
+#define BLOCKSIZE_Y	8
+
+#define BLOCKS_X 			(ScummBufferWidth/BLOCKSIZE_X)
+#define BLOCKS_Y			(ScummBufferHeight/BLOCKSIZE_Y)
+#define BLOCK_ID(x, y)  ((y/BLOCKSIZE_Y)*BLOCKS_X+(x/BLOCKSIZE_X))
+
+OSystem_MorphOS *OSystem_MorphOS::create(int game_id, SCALERTYPE gfx_scaler, bool full_screen)
+{
+	OSystem_MorphOS *syst = new OSystem_MorphOS(game_id, gfx_scaler, full_screen);
+
+	return syst;
+}
+
+OSystem_MorphOS::OSystem_MorphOS(int game_id, SCALERTYPE gfx_mode, bool full_screen)
+{
+	GameID = game_id;
+	ScummScreen = NULL;
+	ScummWindow = NULL;
+	ScummBuffer = NULL;
+	ScummScreenBuffer[0] = NULL;
+	ScummScreenBuffer[1] = NULL;
+	ScummRenderTo = NULL;
+	ScummNoCursor = NULL;
+	ScummMusicThread = NULL;
+	ScummSoundThread = NULL;
+	ScummWinX = -1;
+	ScummWinY = -1;
+	ScummDefaultMouse = false;
+	ScummOrigMouse = false;
+	ScummShakePos = 0;
+	ScummScaler = gfx_mode;
+	ScummScale = (gfx_mode == ST_NONE) ? 0 : 1;
+	ScummDepth = 0;
+	Scumm16ColFmt16 = false;
+	ScummScrWidth = 0;
+	ScummScrHeight = 0;
+	ScreenChanged = false;
+	DirtyBlocks = NULL;
+	BlockColors = NULL;
+	Scaler = NULL;
+	FullScreenMode = full_screen;
+	CDrive = NULL;
+	CDDATrackOffset = 0;
+	strcpy(ScummWndTitle, "ScummVM MorphOS");
+	TimerMsgPort = NULL;
+	TimerIORequest = NULL;
+
+	OpenATimer(&TimerMsgPort, (IORequest **) &TimerIORequest, UNIT_MICROHZ);
+
+	TimerBase = TimerIORequest->tr_node.io_Device;
+	ScummNoCursor = (UWORD *) AllocVec(16, MEMF_CHIP | MEMF_CLEAR);
+	UpdateRegion = NewRegion();
+	NewUpdateRegion = NewRegion();
+	if (!UpdateRegion || !NewUpdateRegion)
+		error("Could not create region for screen update");
+}
+
+OSystem_MorphOS::~OSystem_MorphOS()
+{
+	if (DirtyBlocks)
+	{
+		FreeVec(DirtyBlocks);
+
+		for (int b = 0; b < BLOCKS_X*BLOCKS_Y; b++)
+			FreeVec(BlockColors[b]);
+		FreeVec(BlockColors);
+	}
+
+	if (Scaler)
+		delete Scaler;
+
+	if (UpdateRegion)
+		DisposeRegion(UpdateRegion);
+
+	if (NewUpdateRegion)
+		DisposeRegion(NewUpdateRegion);
+
+	if (CDrive && CDDABase)
+	{
+		CDDA_Stop(CDrive);
+		CDDA_ReleaseDrive(CDrive);
+	}
+
+	if (TimerIORequest)
+	{
+		CloseDevice((IORequest *) TimerIORequest);
+		DeleteIORequest((IORequest *) TimerIORequest);
+	}
+
+	if (TimerMsgPort)
+		DeleteMsgPort(TimerMsgPort);
+
+	if (ScummMusicThread)
+	{
+		Signal((Task *) ScummMusicThread, SIGBREAKF_CTRL_C);
+		ObtainSemaphore(&ScummMusicThreadRunning);	 /* Wait for thread to finish */
+		ReleaseSemaphore(&ScummMusicThreadRunning);
+	}
+
+	if (ScummSoundThread)
+	{
+		Signal((Task *) ScummSoundThread, SIGBREAKF_CTRL_C);
+		ObtainSemaphore(&ScummSoundThreadRunning);	 /* Wait for thread to finish */
+		ReleaseSemaphore(&ScummSoundThreadRunning);
+	}
+
+	if (ScummNoCursor)
+		FreeVec(ScummNoCursor);
+
+	if (ScummBuffer)
+		FreeVec(ScummBuffer);
+
+	if (ScummRenderTo && !ScummScreen)
+		FreeBitMap (ScummRenderTo);
+
+	if (ScummWindow)
+		CloseWindow(ScummWindow);
+
+	if (ScummScreen)
+	{
+		if (ScummScreenBuffer[0])
+			FreeScreenBuffer(ScummScreen, ScummScreenBuffer[0]);
+		if( ScummScreenBuffer[1] )
+			FreeScreenBuffer(ScummScreen, ScummScreenBuffer[1]);
+		CloseScreen(ScummScreen);
+	}
+}
+
+bool OSystem_MorphOS::OpenATimer(MsgPort **port, IORequest **req, ULONG unit, bool required)
+{
+	*req = NULL;
+	const char *err_msg = NULL;
+	
+	*port = CreateMsgPort();
+	if (*port)
+	{
+		*req = (IORequest *) CreateIORequest(*port, sizeof (timerequest));
+		if (*req)
+		{
+			if (OpenDevice(TIMERNAME, unit, *req, 0))
+			{
+				DeleteIORequest(*req);
+				*req = NULL;
+				err_msg = "Failed to open timer device";
+			}
+		}
+		else
+			err_msg = "Failed to create IO request";
+	}
+	else
+		err_msg = "Failed to create message port";
+
+	if (err_msg)
+	{
+		if (required)
+			error(err_msg);
+		warning(err_msg);
+	}
+
+	return *req != NULL;
+}
+
+uint32 OSystem_MorphOS::get_msecs()
+{
+	int ticks = clock();
+	ticks *= (1000/CLOCKS_PER_SEC);
+	return ticks;
+}
+
+void OSystem_MorphOS::delay_msecs(uint msecs)
+{
+	TimerIORequest->tr_node.io_Command = TR_ADDREQUEST;
+	TimerIORequest->tr_time.tv_secs = 0;
+	TimerIORequest->tr_time.tv_micro = msecs*1000;
+	DoIO((IORequest *) TimerIORequest);
+}
+
+void OSystem_MorphOS::set_timer(int timer, int (*callback)(int))
+{
+	warning("set_timer() unexpectedly called");
+}
+
+void *OSystem_MorphOS::create_thread(ThreadProc *proc, void *param)
+{
+	static EmulFunc ThreadEmulFunc;
+
+	ThreadEmulFunc.Trap      = TRAP_FUNC;
+	ThreadEmulFunc.Address	 = (ULONG)proc;
+	ThreadEmulFunc.StackSize = 16000;
+	ThreadEmulFunc.Extension = 0;
+	ThreadEmulFunc.Arg1	    = (ULONG)param;
+	musicProcTags[0].ti_Data = (ULONG)&ThreadEmulFunc;
+	ScummMusicThread = CreateNewProc(musicProcTags);
+	return ScummMusicThread;
+}
+
+void *OSystem_MorphOS::create_mutex(void)
+{
+	SignalSemaphore *sem = (SignalSemaphore *) AllocVec(sizeof (SignalSemaphore), MEMF_PUBLIC);
+
+	if (sem)
+		InitSemaphore(sem);
+
+	return sem;
+}
+
+void OSystem_MorphOS::lock_mutex(void *mutex)
+{
+	ObtainSemaphore((SignalSemaphore *) mutex);
+}
+
+void OSystem_MorphOS::unlock_mutex(void *mutex)
+{
+	ReleaseSemaphore((SignalSemaphore *)mutex);
+}
+
+void OSystem_MorphOS::delete_mutex(void *mutex)
+{
+	FreeVec(mutex);
+}
+
+uint32 OSystem_MorphOS::property(int param, Property *value)
+{
+	switch (param)
+	{
+		case PROP_TOGGLE_FULLSCREEN:
+			CreateScreen(CSDSPTYPE_TOGGLE);
+			return 1;
+
+		case PROP_SET_WINDOW_CAPTION:
+			sprintf(ScummWndTitle, "ScummVM MorphOS - %s", value->caption);
+			if (ScummWindow)
+				SetWindowTitles(ScummWindow, ScummWndTitle, ScummWndTitle);
+			return 1;
+
+		case PROP_OPEN_CD:
+			FindCDTags[0].ti_Data = (ULONG) ((GameID == GID_LOOM256) ? "LoomCD" : "Monkey1CD");
+			if (!CDDABase) CDDABase = OpenLibrary("cdda.library", 2);
+			if (CDDABase)
+			{
+				CDrive = CDDA_FindNextDrive(NULL, FindCDTags);
+				if (!CDrive && GameID == GID_MONKEY)
+				{
+					FindCDTags[0].ti_Data = (ULONG) "Madness";
+					CDrive = CDDA_FindNextDrive(NULL, FindCDTags);
+				}
+				if (CDrive)
+				{
+					if (!CDDA_ObtainDrive(CDrive, CDDA_SHARED_ACCESS, NULL))
+					{
+						CDrive = NULL;
+						warning("Failed to obtain CD drive - music will not play");
+					}
+					else if (GameID == GID_LOOM256)
+					{
+						// Offset correction *may* be required
+						CDS_TrackInfo ti = { sizeof (CDS_TrackInfo) };
+
+						if (CDDA_GetTrackInfo(CDrive, 1, 0, &ti))
+							CDDATrackOffset = ti.ti_TrackStart.tm_Format.tm_Frame-22650;
+					}
+				}
+				else
+					warning( "Could not find game CD inserted in CD-ROM drive - cd audio will not play" );
+			}
+			else
+				warning( "Failed to open cdda.library - cd audio will not play" );
+			break;
+
+		case PROP_SHOW_DEFAULT_CURSOR:
+			if (value->show_cursor)
+				ClearPointer(ScummWindow);
+			else
+				SetPointer(ScummWindow, ScummNoCursor, 1, 1, 0, 0);
+			ScummOrigMouse = ScummDefaultMouse = value->show_cursor;
+			break;
+
+		case PROP_GET_SAMPLE_RATE:
+			return SAMPLES_PER_SEC;
+	}
+
+	return 0;
+}
+
+void OSystem_MorphOS::play_cdrom(int track, int num_loops, int start_frame, int length)
+{
+	if (CDrive && start_frame >= 0)
+	{
+		if (start_frame > 0)
+			start_frame -= CDDATrackOffset;
+
+		PlayTags[0].ti_Data = track;
+		PlayTags[1].ti_Data = start_frame;
+		PlayTags[2].ti_Data = (length == 0) ? track+1 : track;
+		PlayTags[3].ti_Data = length ? start_frame+length : 0;
+		PlayTags[4].ti_Data = (num_loops == 0) ? 1 : num_loops;
+		CDDA_Play(CDrive, PlayTags);
+	}
+}
+
+void OSystem_MorphOS::stop_cdrom()
+{
+	CDDA_Stop(CDrive);
+}
+
+bool OSystem_MorphOS::poll_cdrom()
+{
+	ULONG status;
+
+	if (CDrive == NULL)
+		return false;
+
+	CDDA_GetAttr(CDDA_Status, CDrive, &status);
+	return status == CDDA_Status_Busy;
+}
+
+void OSystem_MorphOS::update_cdrom()
+{
+}
+
+void OSystem_MorphOS::quit()
+{
+	exit(0);
+}
+
+#define CVT8TO32(col)   ((col<<24) | (col<<16) | (col<<8) | col)
+
+void OSystem_MorphOS::set_palette(const byte *colors, uint start, uint num)
+{
+	const byte *data = colors;
+	UWORD changed_colors[256];
+	UWORD num_changed = 0;
+
+	for (uint i = start; i != start+num; i++)
+	{
+		ULONG color32 = (data[0] << 16) | (data[1] << 8) | data[2];
+		if (color32 != ScummColors[i])
+		{
+			if (ScummDepth == 8)
+				SetRGB32(&ScummScreen->ViewPort, i, CVT8TO32(data[0]), CVT8TO32(data[1]), CVT8TO32(data[2]));
+			ScummColors16[i] = Scumm16ColFmt16 ? (((data[0]*31)/255) << 11) | (((data[1]*63)/255) << 5) | ((data[ 2 ]*31)/255) : (((data[0]*31)/255) << 10) | (((data[1]*31)/255) << 5) | ((data[2]*31)/255);
+			ScummColors[i] = color32;
+			changed_colors[num_changed++] = i;
+		}
+		data += 4;
+	}
+
+	if (ScummScale || ScummDepth != 8)
+	{
+		if (DirtyBlocks && num_changed < 200)
+		{
+			for (int b = 0; b < BLOCKS_X*BLOCKS_Y; b++)
+			{
+				UWORD *block_colors = BlockColors[b];
+				UWORD *color_ptr = changed_colors;
+				for (int c = 0; c < num_changed; c++)
+				{
+					if (block_colors[*color_ptr++])
+					{
+						UWORD x, y;
+						x = b % BLOCKS_X;
+						y = b / BLOCKS_X;
+						DirtyBlocks[b] = true;
+						AddUpdateRect(x*BLOCKSIZE_X, y*BLOCKSIZE_Y, BLOCKSIZE_X, BLOCKSIZE_Y);
+						break;
+					}
+				}
+			}
+		}
+		else
+			AddUpdateRect(0, 0, ScummBufferWidth, ScummBufferHeight);
+	}
+}
+
+void OSystem_MorphOS::CreateScreen(CS_DSPTYPE dspType)
+{
+	ULONG mode = INVALID_ID;
+	int   depths[] = { 8, 15, 16, 24, 32, 0 };
+	int   i;
+	Screen *wb = NULL;
+
+	if (dspType != CSDSPTYPE_KEEP)
+		FullScreenMode = (dspType == CSDSPTYPE_FULLSCREEN) || (dspType == CSDSPTYPE_TOGGLE && !FullScreenMode);
+
+	if (ScummRenderTo && !ScummScreen)
+		FreeBitMap(ScummRenderTo);
+	ScummRenderTo = NULL;
+
+	if (ScummWindow)
+	{
+		if (ScummScreen == NULL)
+		{
+			ScummWinX = ScummWindow->LeftEdge;
+			ScummWinY = ScummWindow->TopEdge;
+		}
+		CloseWindow (ScummWindow);
+		ScummWindow = NULL;
+	}
+
+	if (ScummScreen)
+	{
+		if (ScummScreenBuffer[0])
+			FreeScreenBuffer(ScummScreen, ScummScreenBuffer[0]);
+		if (ScummScreenBuffer[1])
+			FreeScreenBuffer(ScummScreen, ScummScreenBuffer[1]);
+		CloseScreen(ScummScreen);
+		ScummScreen = NULL;
+	}
+	
+	ScummScrWidth  = ScummBufferWidth << ScummScale;
+	ScummScrHeight = ScummBufferHeight << ScummScale;
+
+	if (FullScreenMode)
+	{
+		for (i = ScummScale; mode == INVALID_ID && depths[i]; i++)
+			mode = BestCModeIDTags(CYBRBIDTG_NominalWidth, 	  ScummScrWidth,
+										  CYBRBIDTG_NominalHeight,   ScummScrHeight,
+										  CYBRBIDTG_Depth,   		  depths[i],
+										  TAG_DONE
+										 );
+		ScummDepth = depths[i-1];
+
+		if (mode == INVALID_ID)
+			error("Could not find suitable screenmode");
+
+		ScummScreen = OpenScreenTags(NULL, 	SA_AutoScroll, TRUE,
+														SA_Depth,		ScummDepth,
+														SA_Width,		STDSCREENWIDTH,
+														SA_Height,		STDSCREENHEIGHT,
+														SA_DisplayID,	mode,
+														SA_ShowTitle,	FALSE,
+														SA_Type,			CUSTOMSCREEN,
+														SA_Title,		"ScummVM MorphOS",
+														TAG_DONE
+											 );
+
+		if (ScummScreen == NULL)
+			error("Failed to open screen");
+
+		ULONG	RealDepth = GetBitMapAttr(&ScummScreen->BitMap, BMA_DEPTH);
+		if (RealDepth != ScummDepth)
+		{
+			warning("Screen did not open in expected depth");
+			ScummDepth = RealDepth;
+		}
+		ScummScreenBuffer[0] = AllocScreenBuffer(ScummScreen, NULL, SB_SCREEN_BITMAP);
+		ScummScreenBuffer[1] = AllocScreenBuffer(ScummScreen, NULL, 0);
+		ScummRenderTo = ScummScreenBuffer[1]->sb_BitMap;
+		ScummPaintBuffer = 1;
+
+		if (ScummScreenBuffer[0] == NULL || ScummScreenBuffer[1] == NULL)
+			error("Failed to allocate screen buffer");
+
+		// Make both buffers black to avoid grey strip on bottom of screen
+		RastPort rp;
+		InitRastPort(&rp);
+		SetRGB32(&ScummScreen->ViewPort, 0, 0, 0, 0);
+		rp.BitMap = ScummScreenBuffer[0]->sb_BitMap;
+		FillPixelArray(&ScummScreen->RastPort, 0, 0, ScummScreen->Width, ScummScreen->Height, 0);
+		rp.BitMap = ScummRenderTo;
+		FillPixelArray(&rp, 0, 0, ScummScreen->Width, ScummScreen->Height, 0);
+
+		if (ScummDepth == 8)
+		{
+			for (int color = 0; color < 256; color++)
+			{
+				ULONG r, g, b;
+
+				r = (ScummColors[color] >> 16) & 0xff;
+				g = (ScummColors[color] >> 8) & 0xff;
+				b = (ScummColors[color] >> 0) & 0xff;
+				SetRGB32(&ScummScreen->ViewPort, color, CVT8TO32(r), CVT8TO32(g), CVT8TO32(b));
+			}
+		}
+	}
+	else
+	{
+		wb = LockPubScreen(NULL);
+		if (wb == NULL)
+			error("Could not lock default public screen");
+
+		ScreenToFront(wb);
+	}
+
+	ScummWindow = OpenWindowTags(NULL,	WA_Left,				(wb && ScummWinX >= 0) ? ScummWinX : 0,
+													WA_Top,				wb ? ((ScummWinY >= 0) ? ScummWinY : wb->BarHeight+1) : 0,
+													WA_InnerWidth,	   FullScreenMode ? ScummScreen->Width : ScummScrWidth,
+													WA_InnerHeight,   FullScreenMode ? ScummScreen->Height : ScummScrHeight,
+													WA_Activate,		TRUE,
+													WA_Title,		   wb ? ScummWndTitle : NULL,
+													WA_ScreenTitle,	wb ? ScummWndTitle : NULL,
+													WA_Borderless,		FullScreenMode,
+													WA_CloseGadget,	!FullScreenMode,
+													WA_DepthGadget,	!FullScreenMode,
+													WA_DragBar,			!FullScreenMode,
+													WA_ReportMouse,	TRUE,
+													WA_RMBTrap,			TRUE,
+													WA_IDCMP,			IDCMP_RAWKEY 		|
+																			IDCMP_MOUSEMOVE 	|
+																			IDCMP_CLOSEWINDOW |
+																			IDCMP_MOUSEBUTTONS,
+													WA_CustomScreen,  FullScreenMode ? (ULONG)ScummScreen : (ULONG)wb,
+													TAG_DONE
+										 );
+
+	if (wb)
+		UnlockPubScreen(NULL, wb);
+
+	if (ScummWindow == NULL)
+		error("Failed to open window");
+
+	if (!ScummDefaultMouse)
+	{
+		SetPointer(ScummWindow, ScummNoCursor, 1, 1, 0, 0);
+		ScummOrigMouse = false;
+	}
+
+	if (ScummScreen == NULL)
+	{
+		ScummDepth = GetCyberMapAttr(ScummWindow->RPort->BitMap, CYBRMATTR_DEPTH);
+		if (ScummDepth == 8)
+			error("Workbench screen must be running in 15 bit or higher");
+
+		ScummRenderTo = AllocBitMap(ScummScrWidth, ScummScrHeight, ScummDepth, BMF_MINPLANES, ScummWindow->RPort->BitMap);
+		if (ScummRenderTo == NULL)
+			error("Failed to allocate bitmap");
+	}
+
+	if ((ScummDepth == 15 && Scumm16ColFmt16) || (ScummDepth == 16 && !Scumm16ColFmt16))
+	{
+		for (int col = 0; col < 256; col++)
+		{
+			int r = (ScummColors[col] >> 16) & 0xff;
+			int g = (ScummColors[col] >> 8) & 0xff;
+			int b = ScummColors[col] & 0xff;
+			ScummColors16[col] = (Scumm16ColFmt16 == false) ? (((r*31)/255) << 11) | (((g*63)/255) << 5) | ((b*31)/255) : (((r*31)/255) << 10) | (((g*31)/255) << 5) | ((b*31)/255);
+		}
+
+		Scumm16ColFmt16 = (ScummDepth == 16);
+	}
+
+	if (Scaler)
+	{
+		delete Scaler;
+		Scaler = NULL;
+	}
+
+	if (ScummScale)
+	{
+		Scaler = MorphOSScaler::Create(ScummScaler, ScummBuffer, ScummBufferWidth, ScummBufferHeight, ScummColors, ScummColors16, ScummRenderTo);
+		if (Scaler == NULL)
+		{
+			warning("Failed to create scaler - scaling will be disabled");
+			SwitchScalerTo(ST_NONE);
+		}
+	}
+
+	AddUpdateRect(0, 0, ScummBufferWidth, ScummBufferHeight);
+}
+
+void OSystem_MorphOS::SwitchScalerTo(SCALERTYPE newScaler)
+{
+	if (newScaler == ST_NONE && ScummScale != 0)
+	{
+		if (Scaler)
+		{
+			delete Scaler;
+			Scaler = NULL;
+		}
+		ScummScale = 0;
+		ScummScaler = ST_NONE;
+		CreateScreen(ScummScreen ? CSDSPTYPE_FULLSCREEN : CSDSPTYPE_WINDOWED);
+	}
+	else
+	{
+		if (ScummScale == 0)
+		{
+			ScummScale = 1;
+			ScummScaler = newScaler;
+			CreateScreen(ScummScreen ? CSDSPTYPE_FULLSCREEN : CSDSPTYPE_WINDOWED);
+		}
+		else if (ScummScaler != newScaler)
+		{
+			ScummScaler = newScaler;
+			if (Scaler)
+				delete Scaler;
+			Scaler = MorphOSScaler::Create(ScummScaler, ScummBuffer, ScummBufferWidth, ScummBufferHeight, ScummColors, ScummColors16, ScummRenderTo);
+			if (Scaler == NULL)
+			{
+				warning("Failed to create scaler - scaling will be disabled");
+				SwitchScalerTo(ST_NONE);
+			}
+			else
+				AddUpdateRect(0, 0, ScummBufferWidth, ScummBufferHeight);
+		}
+	}
+}
+
+bool OSystem_MorphOS::poll_event(Event *event)
+{
+	IntuiMessage *ScummMsg;
+
+	if (ScummMsg = (IntuiMessage *) GetMsg(ScummWindow->UserPort))
+	{
+		switch (ScummMsg->Class)
+		{
+			case IDCMP_RAWKEY:
+			{
+				InputEvent FakedIEvent;
+				char charbuf;
+            int  qual = 0;
+
+				memset(&FakedIEvent, 0, sizeof (InputEvent));
+				FakedIEvent.ie_Class = IECLASS_RAWKEY;
+				FakedIEvent.ie_Code = ScummMsg->Code;
+
+				if (ScummMsg->Qualifier & (IEQUALIFIER_LALT | IEQUALIFIER_RALT))
+					qual |= KBD_ALT;
+				if (ScummMsg->Qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
+					qual |= KBD_SHIFT;
+				if (ScummMsg->Qualifier & IEQUALIFIER_CONTROL)
+					qual |= KBD_CTRL;
+				event->kbd.flags = qual;
+
+				event->event_code = EVENT_KEYDOWN;
+
+				if (ScummMsg->Code >= 0x50 && ScummMsg->Code <= 0x59)
+				{
+					/*
+					 * Function key
+					 */
+					event->kbd.ascii = (ScummMsg->Code-0x50)+315;
+					event->kbd.keycode = 0;
+				}
+				else if (MapRawKey(&FakedIEvent, &charbuf, 1, NULL) == 1)
+				{
+					if (qual == KBD_CTRL)
+					{
+						switch (charbuf)
+						{
+							case 'z':
+								ReplyMsg((Message *) ScummMsg);
+								quit();
+						}
+					}
+					else if (qual == KBD_ALT)
+					{
+						if (charbuf >= '0' && charbuf <= '9')
+						{
+							SCALERTYPE new_scaler = MorphOSScaler::FindByIndex(charbuf-'0');
+							ReplyMsg((Message *) ScummMsg);
+							if (new_scaler != ST_INVALID)
+								SwitchScalerTo(new_scaler);
+							return false;
+						}
+						else if (charbuf == 'x')
+						{
+							ReplyMsg((Message *) ScummMsg);
+							quit();
+						}
+						else if (charbuf == 0x0d)
+						{
+							ReplyMsg((Message *) ScummMsg);
+							CreateScreen(CSDSPTYPE_TOGGLE);
+                     return false;
+						}
+					}
+
+					event->kbd.ascii = charbuf;
+					event->kbd.keycode = event->kbd.ascii;
+				}
+				break;
+			}
+
+			case IDCMP_MOUSEMOVE:
+			{
+				LONG newx, newy;
+
+				newx = (ScummMsg->MouseX-ScummWindow->BorderLeft) >> ScummScale;
+				newy = (ScummMsg->MouseY-ScummWindow->BorderTop) >> ScummScale;
+
+				if (!FullScreenMode && !ScummDefaultMouse)
+				{
+					if (newx < 0 || newx > ScummBufferWidth ||
+						 newy < 0 || newy > ScummBufferHeight
+						)
+					{
+						if (!ScummOrigMouse)
+						{
+							ScummOrigMouse = true;
+							ClearPointer(ScummWindow);
+						}
+					}
+					else if (ScummOrigMouse)
+					{
+						ScummOrigMouse = false;
+						SetPointer(ScummWindow, ScummNoCursor, 1, 1, 0, 0);
+					}
+				}
+				else if (FullScreenMode)
+					newy = newy <? (ScummScrHeight >> ScummScale)-2;
+
+				event->event_code = EVENT_MOUSEMOVE;
+				event->mouse.x = newx;
+				event->mouse.y = newy;
+				break;
+			}
+
+			case IDCMP_MOUSEBUTTONS:
+			{
+				int newx, newy;
+
+				newx = (ScummMsg->MouseX-ScummWindow->BorderLeft) >> ScummScale;
+				newy = (ScummMsg->MouseY-ScummWindow->BorderTop) >> ScummScale;
+
+				switch (ScummMsg->Code)
+				{
+					case SELECTDOWN:
+						event->event_code = EVENT_LBUTTONDOWN;
+						break;
+
+					case SELECTUP:
+						event->event_code = EVENT_LBUTTONUP;
+						break;
+
+					case MENUDOWN:
+						event->event_code = EVENT_RBUTTONDOWN;
+						break;
+
+					case MENUUP:
+						event->event_code = EVENT_RBUTTONUP;
+						break;
+
+					default:
+						ReplyMsg((Message *)ScummMsg);
+						return false;
+				}
+				event->mouse.x = newx;
+				event->mouse.y = newy;
+				break;
+			}
+
+			case IDCMP_CLOSEWINDOW:
+				ReplyMsg((Message *)ScummMsg);
+				exit(0);
+		}
+
+		if (ScummMsg)
+			ReplyMsg((Message *) ScummMsg);
+
+		return true;
+	}
+
+	return false;
+}
+
+void OSystem_MorphOS::set_shake_pos(int shake_pos)
+{
+	ScummShakePos = shake_pos;
+	AddUpdateRect(0, 0, 320, 200);
+}
+
+#define MOUSE_INTERSECTS(x, y, w, h) \
+	(!((MouseOldX+MouseOldWidth <= x ) || (MouseOldX >= x+w) || \
+		(MouseOldY+MouseOldHeight <= y) || (MouseOldY >= y+h)))
+
+/* Copy part of bitmap */
+void OSystem_MorphOS::copy_rect(const byte *src, int pitch, int x, int y, int w, int h)
+{
+	byte *dst;
+
+	if (x < 0) { w+=x; src-=x; x = 0; }
+	if (y < 0) { h+=y; src-=y*pitch; y = 0; }
+	if (w >= ScummBufferWidth-x) { w = ScummBufferWidth - x; }
+	if (h >= ScummBufferHeight-y) { h = ScummBufferHeight - y; }
+
+	if (w <= 0 || h <= 0)
+		return;
+
+	if (MouseDrawn)
+	{
+		if (MOUSE_INTERSECTS(x, y, w, h))
+			UndrawMouse();
+	}
+
+	AddUpdateRect(x, y, w, h);
+
+	dst = (byte *)ScummBuffer+y*ScummBufferWidth + x;
+	if (DirtyBlocks)
+	{
+		int cx, cy;
+		int block = BLOCK_ID(x, y);
+		int line_block = block;
+		int start_block = BLOCKSIZE_X-(x % BLOCKSIZE_X);
+		int start_y_block = BLOCKSIZE_Y-(y % BLOCKSIZE_Y);
+		int next_block;
+		int next_y_block;
+		UWORD *block_cols = BlockColors[block];
+
+		if (start_block == 0)
+			start_block = BLOCKSIZE_X;
+		if (start_y_block == 0)
+			start_y_block = BLOCKSIZE_Y;
+
+		next_block = start_block;
+		next_y_block = start_y_block;
+		for (cy = 0; cy < h; cy++)
+		{
+			for (cx = 0; cx < w; cx++)
+			{
+				UWORD old_pixel = *dst;
+				UWORD src_pixel = *src++;
+				if (old_pixel != src_pixel)
+				{
+					*dst++ = src_pixel;
+					block_cols[old_pixel]--;
+					block_cols[src_pixel]++;
+				}
+				else
+					dst++;
+				if (--next_block == 0)
+				{
+					block++;
+					block_cols = BlockColors[block];
+					next_block = BLOCKSIZE_X;
+				}
+			}
+			if (--next_y_block == 0)
+			{
+				line_block += BLOCKS_X;
+				next_y_block = BLOCKSIZE_Y;
+			}
+			block = line_block;
+			block_cols = BlockColors[block];
+			next_block = start_block;
+			dst += ScummBufferWidth-w;
+			src += pitch-w;
+		}
+	}
+	else
+	{
+		do
+		{
+			memcpy(dst, src, w);
+			dst += ScummBufferWidth;
+			src += pitch;
+		} while (--h);
+	}
+}
+
+bool OSystem_MorphOS::AddUpdateRect(WORD x, WORD y, WORD w, WORD h)
+{
+	if (x < 0) { w+=x; x = 0; }
+	if (y < 0) { h+=y; y = 0; }
+	if (w >= ScummBufferWidth-x) { w = ScummBufferWidth - x; }
+	if (h >= ScummBufferHeight-y) { h = ScummBufferHeight - y; }
+
+	if (w <= 0 || h <= 0)
+		return false;
+
+	Rectangle update_rect = { x, y, x+w, y+h };
+	OrRectRegion(NewUpdateRegion, &update_rect);
+	ScreenChanged = true;
+
+	return true;
+}
+
+void OSystem_MorphOS::update_screen()
+{
+	DrawMouse();
+
+	if (!ScreenChanged)
+		return;
+
+	OrRegionRegion(NewUpdateRegion, UpdateRegion);
+
+	if (ScummShakePos)
+	{
+		RastPort rp;
+
+		InitRastPort(&rp);
+		rp.BitMap = ScummRenderTo;
+
+		uint32 src_y = 0;
+		uint32 dest_y = 0;
+		if (ScummShakePos < 0)
+			src_y = -ScummShakePos;
+		else
+			dest_y = ScummShakePos;
+
+		if (!ScummScale)
+		{
+			if (ScummDepth == 8)
+				WritePixelArray(ScummBuffer, 0, src_y, ScummBufferWidth, &rp, 0, dest_y, ScummBufferWidth, ScummBufferHeight-src_y-dest_y, RECTFMT_LUT8);
+			else
+				WriteLUTPixelArray(ScummBuffer, 0, src_y, ScummBufferWidth, &rp, ScummColors, 0, dest_y, ScummBufferWidth, ScummBufferHeight-src_y-dest_y, CTABFMT_XRGB8);
+		}
+		else if (Scaler->Prepare(ScummRenderTo))
+		{
+			Scaler->Scale(0, src_y, 0, dest_y, ScummBufferWidth, ScummBufferHeight-src_y-dest_y);
+			Scaler->Finish();
+		}
+
+		if (ScummShakePos < 0)
+			FillPixelArray(&rp, 0, (ScummBufferHeight-1) << ScummScale, ScummScrWidth, -ScummShakePos << ScummScale, 0);
+		else
+			FillPixelArray(&rp, 0, 0, ScummScrWidth, ScummShakePos << ScummScale, 0);
+	}
+	else if (!ScummScale)
+	{
+		RastPort rp;
+
+		InitRastPort(&rp);
+		rp.BitMap = ScummRenderTo;
+
+		uint32 src_x, src_y;
+		uint32 src_w, src_h;
+		uint32 reg_x, reg_y;
+		RegionRectangle *update_rect = UpdateRegion->RegionRectangle;
+
+		reg_x = UpdateRegion->bounds.MinX;
+		reg_y = UpdateRegion->bounds.MinY;
+		while (update_rect)
+		{
+			src_x = update_rect->bounds.MinX;
+			src_y = update_rect->bounds.MinY;
+			src_w = update_rect->bounds.MaxX-src_x;
+			src_h = update_rect->bounds.MaxY-src_y;
+			src_x += reg_x;
+			src_y += reg_y;
+
+			if (src_x) src_x--;
+			if (src_y) src_y--;
+			src_w += 2;
+			if (src_x+src_w >= ScummBufferWidth)
+				src_w = ScummBufferWidth-src_x;
+			src_h += 2;
+			if (src_y+src_h >= ScummBufferHeight)
+				src_h = ScummBufferHeight-src_y;
+
+			if (ScummDepth == 8)
+				WritePixelArray(ScummBuffer, src_x, src_y, ScummBufferWidth, &rp, src_x, src_y, src_w, src_h, RECTFMT_LUT8);
+			else
+				WriteLUTPixelArray(ScummBuffer, src_x, src_y, ScummBufferWidth, &rp, ScummColors, src_x, src_y, src_w, src_h, CTABFMT_XRGB8);
+
+			update_rect = update_rect->Next;
+		}
+	}
+	else
+	{
+		uint32 src_x, src_y;
+		uint32 src_w, src_h;
+		uint32 reg_x, reg_y;
+		RegionRectangle *update_rect = UpdateRegion->RegionRectangle;
+
+		reg_x = UpdateRegion->bounds.MinX;
+		reg_y = UpdateRegion->bounds.MinY;
+
+		if (!Scaler->Prepare(ScummRenderTo))
+			update_rect = NULL;
+
+		while (update_rect)
+		{
+			src_x = update_rect->bounds.MinX;
+			src_y = update_rect->bounds.MinY;
+			src_w = update_rect->bounds.MaxX-src_x;
+			src_h = update_rect->bounds.MaxY-src_y;
+			src_x += reg_x;
+			src_y += reg_y;
+
+			if (src_x) src_x--;
+			if (src_y) src_y--;
+			src_w += 2;
+			if (src_x+src_w >= ScummBufferWidth)
+				src_w = ScummBufferWidth-src_x;
+			src_h += 2;
+			if (src_y+src_h >= ScummBufferHeight)
+				src_h = ScummBufferHeight-src_y;
+
+			Scaler->Scale(src_x, src_y, src_x, src_y, src_w, src_h);
+			update_rect = update_rect->Next;
+		}
+		Scaler->Finish();
+	}
+
+	if (ScummScreen)
+	{
+		while (!ChangeScreenBuffer(ScummScreen, ScummScreenBuffer[ScummPaintBuffer]));
+		ScummPaintBuffer = !ScummPaintBuffer;
+		ScummRenderTo = ScummScreenBuffer[ScummPaintBuffer]->sb_BitMap;
+	}
+	else
+	{
+		int32 x = (UpdateRegion->bounds.MinX-1) << ScummScale;
+		int32 y = (UpdateRegion->bounds.MinY-1) << ScummScale;
+		if (x < 0) x = 0;
+		if (y < 0) y = 0;
+		int32 w = (UpdateRegion->bounds.MaxX << ScummScale)-x+(1 << ScummScale);
+		int32 h = (UpdateRegion->bounds.MaxY << ScummScale)-y+(1 << ScummScale);
+		if (x+w > ScummScrWidth)  w = ScummScrWidth-x;
+		if (y+h > ScummScrHeight) h = ScummScrHeight-y;
+		BltBitMapRastPort(ScummRenderTo, x, y, ScummWindow->RPort, ScummWindow->BorderLeft+x, ScummWindow->BorderTop+y, w, h, ABNC | ABC);
+		WaitBlit();
+	}
+
+	Region *new_region_part = NewUpdateRegion;
+	NewUpdateRegion = UpdateRegion;
+	ClearRegion(NewUpdateRegion);
+	UpdateRegion = new_region_part;
+
+	ScreenChanged = false;
+	memset(DirtyBlocks, 0, BLOCKS_X*BLOCKS_Y*sizeof (bool));
+}
+
+void OSystem_MorphOS::DrawMouse()
+{
+	int x,y;
+	byte *dst,*bak;
+	byte color;
+
+	if (MouseDrawn || !MouseVisible)
+		return;
+	MouseDrawn = true;
+
+	const int ydraw = MouseY - MouseHotspotY;
+	const int xdraw = MouseX - MouseHotspotX;
+	const int w = MouseWidth;
+	const int h = MouseHeight;
+	bak = MouseBackup;
+	byte *buf = MouseImage;
+
+	MouseOldX = xdraw;
+	MouseOldY = ydraw;
+	MouseOldWidth = w;
+	MouseOldHeight = h;
+
+	AddUpdateRect(xdraw, ydraw, w, h);
+
+	dst = (byte*)ScummBuffer + ydraw*ScummBufferWidth + xdraw;
+	bak = MouseBackup;
+
+	for (y = 0; y < h; y++, dst += ScummBufferWidth, bak += MAX_MOUSE_W, buf += w)
+	{
+		if ((uint)(ydraw+y) < ScummBufferHeight)
+		{
+			for( x = 0; x<w; x++ )
+			{
+				if ((uint)(xdraw+x) < ScummBufferWidth)
+				{
+					bak[x] = dst[x];
+					if ((color=buf[x])!=0xFF)
+						dst[ x ] = color;
+				}
+			}
+		}
+		else
+			break;
+	}
+}
+
+void OSystem_MorphOS::UndrawMouse()
+{
+	int x,y;
+	byte *dst,*bak;
+
+	if (!MouseDrawn)
+		return;
+	MouseDrawn = false;
+
+	dst = (byte*)ScummBuffer + MouseOldY*ScummBufferWidth + MouseOldX;
+	bak = MouseBackup;
+
+	AddUpdateRect(MouseOldX, MouseOldY, MouseOldWidth, MouseOldHeight);
+
+	for (y = 0; y < MouseOldHeight; y++, bak += MAX_MOUSE_W, dst += ScummBufferWidth)
+	{
+		if ((uint)(MouseOldY + y) < ScummBufferHeight)
+		{
+			for (x = 0; x < MouseOldWidth; x++)
+			{
+				if ((uint)(MouseOldX + x) < ScummBufferWidth)
+					dst[x] = bak[x];
+			}
+		}
+		else
+			break;
+	}
+}
+
+bool OSystem_MorphOS::show_mouse(bool visible)
+{
+	if (MouseVisible == visible)
+		return visible;
+
+	bool last = MouseVisible;
+	MouseVisible = visible;
+
+	if (!visible)
+		UndrawMouse();
+
+	return last;
+}
+
+void OSystem_MorphOS::set_mouse_pos(int x, int y)
+{
+	if (x != MouseX || y != MouseY)
+	{
+		MouseX = x;
+		MouseY = y;
+		UndrawMouse();
+	}
+}
+
+void OSystem_MorphOS::set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y)
+{
+	MouseWidth = w;
+	MouseHeight	= h;
+
+	MouseHotspotX = hotspot_x;
+	MouseHotspotY = hotspot_y;
+
+	MouseImage = (byte*)buf;
+
+	UndrawMouse();
+}
+
+bool OSystem_MorphOS::set_sound_proc(void *param, OSystem::SoundProc *proc, byte format)
+{
+	static EmulFunc MySoundEmulFunc;
+
+	SoundProc = proc;
+	SoundParam = param;
+
+	/*
+	 * Create Sound Thread
+	 */
+	MySoundEmulFunc.Trap      = TRAP_FUNC;
+	MySoundEmulFunc.Address	  = (ULONG)&morphos_sound_thread;
+	MySoundEmulFunc.StackSize = 8192;
+	MySoundEmulFunc.Extension = 0;
+	MySoundEmulFunc.Arg1	     = (ULONG)this;
+	MySoundEmulFunc.Arg2	     = AHIST_S16S;
+
+	soundProcTags[0].ti_Data = (ULONG)&MySoundEmulFunc;
+	ScummSoundThread = CreateNewProc(soundProcTags);
+
+	if (!ScummSoundThread)
+	{
+		puts("Failed to create sound thread");
+		exit(1);
+	}
+
+	return true;
+}
+
+void OSystem_MorphOS::fill_sound(byte *stream, int len)
+{
+	if (SoundProc)
+		SoundProc(SoundParam, stream, len);
+	else
+		memset(stream, 0x0, len);
+}
+
+void OSystem_MorphOS::init_size(uint w, uint h)
+{
+	/*
+	 * Allocate image buffer
+	 */
+	ScummBuffer = AllocVec(w*h, MEMF_CLEAR);
+	
+	if (ScummBuffer == NULL)
+	{
+		puts("Couldn't allocate image buffer");
+		exit(1);
+	}
+
+	memset(ScummColors, 0, 256*sizeof (ULONG));
+
+	ScummBufferWidth = w;
+	ScummBufferHeight = h;
+
+	DirtyBlocks = (bool *) AllocVec(BLOCKS_X*BLOCKS_Y*sizeof (bool), MEMF_CLEAR);
+	if (DirtyBlocks)
+	{
+		BlockColors = (UWORD **) AllocVec(BLOCKS_X*BLOCKS_Y*sizeof (UWORD *), MEMF_CLEAR);
+		if (BlockColors)
+		{
+			int b;
+
+			for (b = 0; b < BLOCKS_X*BLOCKS_Y; b++)
+			{
+				BlockColors[b] = (UWORD *) AllocVec(256*sizeof (UWORD), MEMF_CLEAR);
+				if (BlockColors[b] == NULL)
+					break;
+				BlockColors[b][0] = BLOCKSIZE_X*BLOCKSIZE_Y;
+			}
+
+			if (b < BLOCKS_X*BLOCKS_Y)
+			{
+				for (--b; b >= 0; --b)
+					FreeVec(BlockColors[b]);
+				FreeVec(BlockColors);
+				BlockColors = NULL;
+			}
+		}
+
+		if (!BlockColors)
+		{
+			FreeVec(DirtyBlocks);
+			DirtyBlocks = NULL;
+		}
+	}
+
+	CreateScreen(CSDSPTYPE_KEEP);
+}
+
diff --git a/backends/morphos/morphos.h b/backends/morphos/morphos.h
new file mode 100644
index 0000000000..75d2c79f7b
--- /dev/null
+++ b/backends/morphos/morphos.h
@@ -0,0 +1,206 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2002 Rüdiger Hanke (MorphOS port)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * MorphOS-specific header file
+ *
+ * $Header$
+ *
+ */
+
+#ifndef MORPHOS_MORPHOS_H
+#define MORPHOS_MORPHOS_H
+
+#include <exec/semaphores.h>
+#include <devices/amidi.h>
+#include <graphics/regions.h>
+#include <intuition/intuition.h>
+#include <intuition/screens.h>
+#include <libraries/cdda.h>
+
+#include "morphos_scaler.h"
+
+class OSystem_MorphOS : public OSystem
+{
+	public:
+					OSystem_MorphOS(int game_id, SCALERTYPE gfx_mode, bool full_screen);
+		virtual ~OSystem_MorphOS();
+
+		// Set colors of the palette
+		virtual void set_palette(const byte *colors, uint start, uint num);
+
+		// Set the size of the video bitmap.
+		// Typically, 320x200
+		virtual void init_size(uint w, uint h);
+
+		// Draw a bitmap to screen.
+		// The screen will not be updated to reflect the new bitmap
+		virtual void copy_rect(const byte *buf, int pitch, int x, int y, int w, int h);
+
+		// Update the dirty areas of the screen
+		virtual void update_screen();
+
+		// Either show or hide the mouse cursor
+		virtual bool show_mouse(bool visible);
+
+		// Set the position of the mouse cursor
+		virtual void set_mouse_pos(int x, int y);
+
+		// Set the bitmap that's used when drawing the cursor.
+		virtual void set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y);
+
+		// Shaking is used in SCUMM. Set current shake position.
+		virtual void set_shake_pos(int shake_pos);
+
+		// Get the number of milliseconds since the program was started.
+		virtual uint32 get_msecs();
+
+		// Delay for a specified amount of milliseconds
+		virtual void delay_msecs(uint msecs);
+
+		// Add a new callback timer
+		virtual void set_timer(int timer, int (*callback)(int));
+
+		// Mutex handling
+		virtual void *create_mutex(void);
+		virtual void lock_mutex(void *mutex);
+		virtual void unlock_mutex(void *mutex);
+		virtual void delete_mutex(void *mutex);
+
+		// Create a thread
+		virtual void *create_thread(ThreadProc *proc, void *param);
+
+		// Get the next event.
+		// Returns true if an event was retrieved.
+		virtual bool poll_event(Event *event);
+
+		// Set the function to be invoked whenever samples need to be generated
+		virtual bool set_sound_proc(void *param, SoundProc *proc, byte format);
+				  void fill_sound    (byte * stream, int len);
+
+		virtual uint32 property(int param, Property *value);
+
+		// Poll cdrom status
+		// Returns true if cd audio is playing
+		virtual bool poll_cdrom();
+
+		// Play cdrom audio track
+		virtual void play_cdrom(int track, int num_loops, int start_frame, int length);
+
+		// Stop cdrom audio track
+		virtual void stop_cdrom();
+
+		// Update cdrom audio status
+		virtual void update_cdrom();
+
+		// Quit
+		virtual void quit();
+
+		static OSystem_MorphOS *create(int game_id, SCALERTYPE gfx_scaler, bool full_screen);
+
+		static bool OpenATimer(MsgPort **port, IORequest **req, ULONG unit, bool required = true);
+
+	private:
+		typedef enum { CSDSPTYPE_WINDOWED, CSDSPTYPE_FULLSCREEN, CSDSPTYPE_TOGGLE, CSDSPTYPE_KEEP } CS_DSPTYPE;
+
+		static const int MAX_MOUSE_W = 40;
+		static const int MAX_MOUSE_H = 40;
+
+		void   CreateScreen(CS_DSPTYPE dspType);
+		void 	 SwitchScalerTo(SCALERTYPE newScaler);
+		bool   AddUpdateRect(WORD x, WORD y, WORD w, WORD h);
+
+		void   DrawMouse();
+		void   UndrawMouse();
+
+		/* Display-related attributes */
+		Screen  	    *ScummScreen;
+		Window  	    *ScummWindow;
+		char 			  ScummWndTitle[125];
+		APTR          ScummBuffer;
+		int			  ScummBufferWidth;
+		int			  ScummBufferHeight;
+		ScreenBuffer *ScummScreenBuffer[2];
+		BitMap  	    *ScummRenderTo;
+		ULONG			  ScummPaintBuffer;
+		int			  ScummScrWidth;
+		int 			  ScummScrHeight;
+		int			  ScummDepth;
+		bool 			  Scumm16ColFmt16;
+		UWORD 		 *ScummNoCursor;
+		ULONG 		  ScummColors[256];
+		USHORT 		  ScummColors16[256];
+		WORD			  ScummWinX;
+		WORD			  ScummWinY;
+		bool			  ScummDefaultMouse;
+		bool			  ScummOrigMouse;
+		int 			  ScummShakePos;
+		bool			  FullScreenMode;
+		bool 			  ScreenChanged;
+		UWORD			**BlockColors;
+		bool			 *DirtyBlocks;
+		Region 		 *UpdateRegion;
+		Region 		 *NewUpdateRegion;
+
+		/* Sound-related attributes */
+		Process   *ScummMusicThread;
+		Process 	 *ScummSoundThread;
+		SoundProc *SoundProc;
+		void      *SoundParam;
+
+		/* CD-ROM related attributes */
+		CDRIVEPTR CDrive;
+		ULONG 	 CDDATrackOffset;
+
+		/* Scaling-related attributes */
+		SCALERTYPE ScummScaler;
+		int  		  ScummScale;
+		MorphOSScaler *Scaler;
+
+		/* Mouse cursor-related attributes */
+		bool  MouseVisible, MouseDrawn;
+		int   MouseX, MouseY;
+		int   MouseWidth, MouseHeight;
+		int   MouseOldX, MouseOldY;
+		int   MouseOldWidth, MouseOldHeight;
+		int   MouseHotspotX, MouseHotspotY;
+		byte *MouseImage, MouseBackup[MAX_MOUSE_W*MAX_MOUSE_H];
+
+		/* Timer-related attributes */
+		MsgPort 	   *TimerMsgPort;
+		timerequest *TimerIORequest;
+
+		/* Game-related attributes */
+		int   GameID;
+};
+
+int morphos_sound_thread(OSystem_MorphOS *syst, ULONG SampleType);
+bool init_morphos_music(ULONG MidiUnit);
+void exit_morphos_music();
+
+int morphos_main(int argc, char *argv[]);
+
+extern OSystem_MorphOS *TheSystem;
+extern SignalSemaphore ScummMusicThreadRunning;
+extern SignalSemaphore ScummSoundThreadRunning;
+
+extern STRPTR ScummMusicDriver;
+extern LONG   ScummMidiUnit;
+extern IOMidiRequest *ScummMidiRequest;
+extern timerequest   *MusicTimerIORequest;
+
+#endif
+
diff --git a/backends/morphos/morphos_scaler.cpp b/backends/morphos/morphos_scaler.cpp
new file mode 100644
index 0000000000..dca4383016
--- /dev/null
+++ b/backends/morphos/morphos_scaler.cpp
@@ -0,0 +1,823 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ */
+
+#include "stdafx.h"
+#include "scumm.h"
+
+#include <exec/types.h>
+#include <cybergraphics/cybergraphics.h>
+
+#include <proto/cybergraphics.h>
+
+#include "morphos.h"
+#include "morphos_scaler.h"
+
+#define GET_RESULT(A, B, C, D) ((A != C || A != D) - (B != C || B != D))
+#define INTERPOLATE(A, B) (((A & colorMask) >> 1) + ((B & colorMask) >> 1) + (A & B & lowPixelMask))
+#define Q_INTERPOLATE(A, B, C, D) ((A & qcolorMask) >> 2) + ((B & qcolorMask) >> 2) + ((C & qcolorMask) >> 2) + ((D & qcolorMask) >> 2) + ((((A & qlowpixelMask) + (B & qlowpixelMask) + (C & qlowpixelMask) + (D & qlowpixelMask)) >> 2) & qlowpixelMask)
+#define SWAP_WORD(word) word = ((word & 0xff) << 8) | (word >> 8)
+
+MorphOSScaler::GfxScaler MorphOSScaler::ScummScalers[11]
+	=	{ { "none", 	   "normal",	  ST_NONE },
+		  { "Point", 		"2x",			  ST_POINT },
+		  { "AdvMame2x",  "advmame2x",  ST_ADVMAME2X },
+		  { "SuperEagle", "supereagle", ST_SUPEREAGLE },
+		  { "Super2xSaI", "super2xsai", ST_SUPER2XSAI },
+		  { NULL, NULL, ST_INVALID },
+		  { NULL, NULL, ST_INVALID },
+		  { NULL, NULL, ST_INVALID },
+		  { NULL, NULL, ST_INVALID },
+		  { NULL, NULL, ST_INVALID },
+		  // This is the end marker ... do not assign a scaler to it!
+		  { NULL, NULL, ST_INVALID }
+		};
+
+MorphOSScaler::MorphOSScaler(APTR buffer, int width, int height, ULONG *col_table, UWORD *col_table16, BitMap *bmap)
+{
+	dest = NULL;
+	handle = NULL;
+
+	Buffer = buffer;
+	BufferWidth = width;
+	BufferHeight = height;
+
+	ScummColors = col_table;
+	ScummColors16 = col_table16;
+
+	/* Initialize scaling stuff */
+	int minr, ming, minb;
+	ULONG depth = GetCyberMapAttr(bmap, CYBRMATTR_DEPTH);
+
+	if (depth > 16)
+	{
+		minr = 1 << 16;
+		ming = 1 << 8;
+		minb = 1;
+	}
+	else
+	{
+		minr = 1 << ((depth == 15) ? 10 : 11);
+		ming = 1 << 5;
+		minb = 1;
+	}
+
+	int pixfmt = GetCyberMapAttr(bmap, CYBRMATTR_PIXFMT);
+
+	ScummPCMode = false;
+	if (pixfmt == PIXFMT_RGB15PC || pixfmt == PIXFMT_BGR15PC ||
+		pixfmt == PIXFMT_RGB16PC || pixfmt == PIXFMT_BGR16PC)
+		ScummPCMode = true;
+	
+	colorMask = (MakeColor(pixfmt, 255, 0, 0) - minr) | (MakeColor(pixfmt, 0, 255, 0) - ming) | (MakeColor(pixfmt, 0, 0, 255) - minb);
+	lowPixelMask = minr | ming | minb;
+	qcolorMask = (MakeColor(pixfmt, 255, 0, 0) - 3*minr) | (MakeColor(pixfmt, 0, 255, 0) - 3*ming) | (MakeColor(pixfmt, 0, 0, 255) - 3*minb);
+	qlowpixelMask = (minr * 3) | (ming * 3) | (minb * 3);
+	redblueMask = MakeColor(pixfmt, 255, 0, 255);
+	greenMask = MakeColor(pixfmt, 0, 255, 0);
+
+	PixelsPerMask = (depth <= 16) ? 2 : 1;
+
+	if (PixelsPerMask == 2)
+	{
+		colorMask |= (colorMask << 16);
+		qcolorMask |= (qcolorMask << 16);
+		lowPixelMask |= (lowPixelMask << 16);
+		qlowpixelMask |= (qlowpixelMask << 16);
+	}
+}
+
+MorphOSScaler::~MorphOSScaler()
+{
+	Finish();
+}
+
+MorphOSScaler *MorphOSScaler::Create(SCALERTYPE scaler_type, APTR buffer, int width, int height, ULONG *col_table, UWORD *col_table16, BitMap *bmap)
+{
+	MorphOSScaler *new_scaler = NULL;
+
+	switch (scaler_type)
+	{
+		case ST_POINT:
+			new_scaler = new PointScaler(buffer, width, height, col_table, col_table16, bmap);
+			break;
+
+		case ST_ADVMAME2X:
+			new_scaler = new AdvMame2xScaler(buffer, width, height, col_table, col_table16, bmap);
+			break;
+
+		case ST_SUPEREAGLE:
+			new_scaler = new SuperEagleScaler(buffer, width, height, col_table, col_table16, bmap);
+			break;
+
+		case ST_SUPER2XSAI:
+			new_scaler = new Super2xSaIScaler(buffer, width, height, col_table, col_table16, bmap);
+			break;
+
+		default:
+			warning("Invalid scaler requested - falling back to Super2xSaI");
+			new_scaler = new Super2xSaIScaler(buffer, width, height, col_table, col_table16, bmap);
+			break;
+	}
+
+	return new_scaler;
+}
+
+bool MorphOSScaler::Prepare(BitMap *render_bmap)
+{
+	handle = LockBitMapTags(render_bmap, LBMI_BYTESPERPIX, &dest_bpp,
+										 LBMI_BYTESPERROW, &dest_pitch,
+										 LBMI_BASEADDRESS, &dest,
+										 LBMI_PIXFMT, &dest_pixfmt,
+										 TAG_DONE);
+
+	return handle != NULL;
+}
+
+void MorphOSScaler::Finish()
+{
+	if (handle)
+	{
+		UnLockBitMap(handle);
+		handle = NULL;
+	}
+}
+
+uint32 MorphOSScaler::MakeColor(int pixfmt, int r, int g, int b)
+{
+	uint32 col = 0;
+
+	switch (pixfmt)
+	{
+		case PIXFMT_RGB15:
+		case PIXFMT_RGB15PC:
+			col = (((r*31)/255) << 10) | (((g*31)/255) << 5) | ((b*31)/255);
+			break;
+
+		case PIXFMT_BGR15:
+		case PIXFMT_BGR15PC:
+			col = (((b*31)/255) << 10) | (((g*31)/255) << 5) | ((r*31)/255);
+			break;
+
+		case PIXFMT_RGB16:
+		case PIXFMT_RGB16PC:
+			col = (((r*31)/255) << 11) | (((g*63)/255) << 5) | ((b*31)/255);
+			break;
+
+		case PIXFMT_BGR16:
+		case PIXFMT_BGR16PC:
+			col = (((b*31)/255) << 11) | (((g*63)/255) << 5) | ((r*31)/255);
+			break;
+
+		case PIXFMT_RGB24:
+		case PIXFMT_ARGB32:
+			col = (r << 16) | (g << 8) | b;
+			break;
+
+		case PIXFMT_BGR24:
+			col = (b << 16) | (g << 8) | r;
+			break;
+
+		case PIXFMT_BGRA32:
+			col = (b << 24) | (g << 16) | (r << 8);
+			break;
+
+		case PIXFMT_RGBA32:
+			col = (r << 24) | (g << 16) | (b << 8);
+			break;
+
+		default:
+			error("Unsupported pixel format: %d. Please contact author at tomjoad@muenster.de.", pixfmt);
+	}
+
+	return col;
+}
+
+void Super2xSaIScaler::Scale(uint32 src_x, uint32 src_y, uint32 dest_x, uint32 dest_y, uint32 width, uint32 height)
+{
+	unsigned int x, y;
+	unsigned long color[16];
+	byte *src;
+
+	if (!handle)
+		return;
+
+	src = ((byte *)Buffer)+src_y*BufferWidth+src_x;
+
+	/* Point to the first 3 lines. */
+	src_line[0] = src;
+	src_line[1] = src;
+	src_line[2] = src + BufferWidth;
+	src_line[3] = src + BufferWidth * 2;
+
+	dst_line[0] = dest+dest_y*2*dest_pitch+dest_x*2*dest_bpp;
+	dst_line[1] = dst_line[0]+dest_pitch;
+
+	if (PixelsPerMask == 2)
+	{
+		byte *sbp;
+		sbp = src_line[0];
+		color[0] = ScummColors16[*sbp];       color[1] = color[0];   color[2] = color[0];    color[3] = color[0];
+		color[4] = color[0];   color[5] = color[0];   color[6] = ScummColors16[*(sbp+1)];  color[7] = ScummColors16[*(sbp+2)];
+		sbp = src_line[2];
+		color[8] = ScummColors16[*sbp];     color[9] = color[8];     color[10] = ScummColors16[*(sbp+1)]; color[11] = ScummColors16[*(sbp+2)];
+		sbp = src_line[3];
+		color[12] = ScummColors16[*sbp];    color[13] = color[12];   color[14] = ScummColors16[*(sbp+1)]; color[15] = ScummColors16[*(sbp+2)];
+	}
+	else
+	{
+		byte *lbp;
+		lbp = src_line[0];
+		color[0] = ScummColors[*lbp];       color[1] = color[0];   color[2] = color[0];    color[3] = color[0];
+		color[4] = color[0];   color[5] = color[0];   color[6] = ScummColors[*(lbp+1)];  color[7] = ScummColors[*(lbp+2)];
+		lbp = src_line[2];
+		color[8] = ScummColors[*lbp];     color[9] = color[8];     color[10] = ScummColors[*(lbp+1)]; color[11] = ScummColors[*(lbp+2)];
+		lbp = src_line[3];
+		color[12] = ScummColors[*lbp];    color[13] = color[12];   color[14] = ScummColors[*(lbp+1)]; color[15] = ScummColors[*(lbp+2)];
+	}
+
+	for (y = 0; y < height; y++)
+	{
+		for (x = 0; x < width; x++)
+		{
+			unsigned long product1a, product1b, product2a, product2b;
+
+//---------------------------------------  B0 B1 B2 B3    0  1  2  3
+//                                         4  5* 6  S2 -> 4  5* 6  7
+//                                         1  2  3  S1    8  9 10 11
+//                                         A0 A1 A2 A3   12 13 14 15
+//--------------------------------------
+			if (color[9] == color[6] && color[5] != color[10])
+			{
+				product2b = color[9];
+				product1b = product2b;
+			}
+			else if (color[5] == color[10] && color[9] != color[6])
+			{
+				product2b = color[5];
+				product1b = product2b;
+			}
+			else if (color[5] == color[10] && color[9] == color[6])
+			{
+				int r = 0;
+
+				r += GET_RESULT(color[6], color[5], color[8], color[13]);
+				r += GET_RESULT(color[6], color[5], color[4], color[1]);
+				r += GET_RESULT(color[6], color[5], color[14], color[11]);
+				r += GET_RESULT(color[6], color[5], color[2], color[7]);
+
+				if (r > 0)
+					product1b = color[6];
+				else if (r < 0)
+					product1b = color[5];
+				else
+					product1b = INTERPOLATE(color[5], color[6]);
+
+				product2b = product1b;
+
+			}
+			else
+			{
+				if (color[6] == color[10] && color[10] == color[13] && color[9] != color[14] && color[10] != color[12])
+					product2b = Q_INTERPOLATE(color[10], color[10], color[10], color[9]);
+				else if (color[5] == color[9] && color[9] == color[14] && color[13] != color[10] && color[9] != color[15])
+					product2b = Q_INTERPOLATE(color[9], color[9], color[9], color[10]);
+				else
+					product2b = INTERPOLATE(color[9], color[10]);
+
+				if (color[6] == color[10] && color[6] == color[1] && color[5] != color[2] && color[6] != color[0])
+					product1b = Q_INTERPOLATE(color[6], color[6], color[6], color[5]);
+				else if (color[5] == color[9] && color[5] == color[2] && color[1] != color[6] && color[5] != color[3])
+					product1b = Q_INTERPOLATE(color[6], color[5], color[5], color[5]);
+				else
+					product1b = INTERPOLATE(color[5], color[6]);
+			}
+
+			if (color[5] == color[10] && color[9] != color[6] && color[4] == color[5] && color[5] != color[14])
+				product2a = INTERPOLATE(color[9], color[5]);
+			else if (color[5] == color[8] && color[6] == color[5] && color[4] != color[9] && color[5] != color[12])
+				product2a = INTERPOLATE(color[9], color[5]);
+			else
+				product2a = color[9];
+
+			if (color[9] == color[6] && color[5] != color[10] && color[8] == color[9] && color[9] != color[2])
+				product1a = INTERPOLATE(color[9], color[5]);
+			else if (color[4] == color[9] && color[10] == color[9] && color[8] != color[5] && color[9] != color[0])
+				product1a = INTERPOLATE(color[9], color[5]);
+			else
+				product1a = color[5];
+
+			if (PixelsPerMask == 2)
+			{
+				if (ScummPCMode)
+				{
+					SWAP_WORD(product1a);
+					SWAP_WORD(product1b);
+					SWAP_WORD(product2a);
+					SWAP_WORD(product2b);
+				}
+				*((unsigned long *) (&dst_line[0][x * 4])) = (product1a << 16) | product1b;
+				*((unsigned long *) (&dst_line[1][x * 4])) = (product2a << 16) | product2b;
+			}
+			else
+			{
+				*((unsigned long *) (&dst_line[0][x * 8])) = product1a;
+				*((unsigned long *) (&dst_line[0][x * 8 + 4])) = product1b;
+				*((unsigned long *) (&dst_line[1][x * 8])) = product2a;
+				*((unsigned long *) (&dst_line[1][x * 8 + 4])) = product2b;
+			}
+
+			/* Move color matrix forward */
+			color[0] = color[1]; color[4] = color[5]; color[8] = color[9];   color[12] = color[13];
+			color[1] = color[2]; color[5] = color[6]; color[9] = color[10];  color[13] = color[14];
+			color[2] = color[3]; color[6] = color[7]; color[10] = color[11]; color[14] = color[15];
+
+			if (src_x+x < BufferWidth-3)
+			{
+				x += 3;
+				if (PixelsPerMask == 2)
+				{
+					color[3] = ScummColors16[*(src_line[0] + x) ];
+					color[7] = ScummColors16[*(src_line[1] + x) ];
+					color[11] = ScummColors16[*(src_line[2] + x) ];
+					color[15] = ScummColors16[*(src_line[3] + x) ];
+				}
+				else
+				{
+					color[3] = ScummColors[*(src_line[0] + x)];
+					color[7] = ScummColors[*(src_line[1] + x)];
+					color[11] = ScummColors[*(src_line[2] + x)];
+					color[15] = ScummColors[*(src_line[3] + x)];
+				}
+				x -= 3;
+			}
+		}
+
+		/* We're done with one line, so we shift the source lines up */
+		src_line[0] = src_line[1];
+		src_line[1] = src_line[2];
+		src_line[2] = src_line[3];
+
+		/* Read next line */
+		if (src_y + y + 3 >= BufferHeight)
+			src_line[3] = src_line[2];
+		else
+			src_line[3] = src_line[2] + BufferWidth;
+
+		/* Then shift the color matrix up */
+		if (PixelsPerMask == 2)
+		{
+			byte *sbp;
+			sbp = src_line[0];
+			color[0] = ScummColors16[*sbp];     color[1] = color[0];    color[2] = ScummColors16[ *(sbp + 1) ];  color[3] = ScummColors16[*(sbp + 2)];
+			sbp = src_line[1];
+			color[4] = ScummColors16[*sbp];     color[5] = color[4];    color[6] = ScummColors16[ *(sbp + 1) ];  color[7] = ScummColors16[*(sbp + 2)];
+			sbp = src_line[2];
+			color[8] = ScummColors16[*sbp];     color[9] = color[8];    color[10] = ScummColors16[ *(sbp + 1) ]; color[11] = ScummColors16[*(sbp + 2)];
+			sbp = src_line[3];
+			color[12] = ScummColors16[*sbp];    color[13] = color[12];  color[14] = ScummColors16[ *(sbp + 1) ]; color[15] = ScummColors16[*(sbp + 2)];
+
+			if (src_x + x > 0)
+			{
+				color[0] = ScummColors16[src_line[0][-1]];
+				color[4] = ScummColors16[src_line[1][-1]];
+				color[8] = ScummColors16[src_line[2][-1]];
+				color[12] = ScummColors16[src_line[3][-1]];
+			}
+		}
+		else
+		{
+			byte *lbp;
+			lbp = src_line[0];
+			color[0] = ScummColors[*lbp];     color[1] = color[0];    color[2] = ScummColors[ *(lbp + 1) ];  color[3] = ScummColors[*(lbp+2)];
+			lbp = src_line[1];
+			color[4] = ScummColors[*lbp];     color[5] = color[4];    color[6] = ScummColors[ *(lbp + 1) ];  color[7] = ScummColors[*(lbp+2)];
+			lbp = src_line[2];
+			color[8] = ScummColors[*lbp];     color[9] = color[8];    color[10] = ScummColors[ *(lbp + 1) ]; color[11] = ScummColors[*(lbp+2)];
+			lbp = src_line[3];
+			color[12] = ScummColors[*lbp];    color[13] = color[12];  color[14] = ScummColors[ *(lbp + 1) ]; color[15] = ScummColors[*(lbp+2)];
+		}
+
+		if (src_y + y < BufferHeight - 1)
+		{
+			dst_line[0] = dst_line[1]+dest_pitch;
+			dst_line[1] = dst_line[0]+dest_pitch;
+		}
+	}
+}
+
+void SuperEagleScaler::Scale(uint32 src_x, uint32 src_y, uint32 dest_x, uint32 dest_y, uint32 width, uint32 height)
+{
+	unsigned int x, y;
+	unsigned long color[12];
+	byte *src;
+
+	if (!handle)
+		return;
+
+	src = (byte *)Buffer+src_y*BufferWidth+src_x;
+
+	/* Point to the first 3 lines. */
+	src_line[0] = src;
+	src_line[1] = src;
+	src_line[2] = src + BufferWidth;
+	src_line[3] = src + BufferWidth * 2;
+
+	dst_line[0] = dest+dest_y*2*dest_pitch+dest_x*2*dest_bpp;
+	dst_line[1] = dst_line[0]+dest_pitch;
+
+	x = 0, y = 0;
+
+	if (PixelsPerMask == 2)
+	{
+		byte *sbp;
+		sbp = src_line[0];
+		color[0] = ScummColors16[*sbp];       color[1] = color[0];   color[2] = color[0];    color[3] = color[0];
+		color[4] = ScummColors16[*(sbp+1)]; color[5] = ScummColors16[*(sbp+2)];
+		sbp = src_line[2];
+		color[6] = ScummColors16[*sbp];     color[7] = color[6];     color[8] = ScummColors16[*(sbp+1)]; color[9] = ScummColors16[*(sbp+2)];
+		sbp = src_line[3];
+		color[10] = ScummColors16[*sbp];    color[11] = ScummColors16[*(sbp+1)];
+	}
+	else
+	{
+		byte *lbp;
+		lbp = src_line[0];
+		color[0] = ScummColors[*lbp];       color[1] = color[0];   color[2] = color[0];    color[3] = color[0];
+		color[4] = ScummColors[*(lbp+1)]; color[5] = ScummColors[*(lbp+2)];
+		lbp = src_line[2];
+		color[6] = ScummColors[*lbp];     color[7] = color[6];     color[8] = ScummColors[*(lbp+1)]; color[9] = ScummColors[*(lbp+2)];
+		lbp = src_line[3];
+		color[10] = ScummColors[*lbp];    color[11] = ScummColors[*(lbp+1)];
+	}
+
+	for (y = 0; y < height; y++)
+	{
+		/* Todo: x = width - 2, x = width - 1 */
+
+		for (x = 0; x < width; x++)
+		{
+			unsigned long product1a, product1b, product2a, product2b;
+
+//---------------------------------------     B1 B2           0  1
+//                                         4  5  6  S2 ->  2  3  4  5
+//                                         1  2  3  S1     6  7  8  9
+//                                            A1 A2          10 11
+
+			if (color[7] == color[4] && color[3] != color[8])
+			{
+				product1b = product2a = color[7];
+
+				if ((color[6] == color[7]) || (color[4] == color[1]))
+					product1a = INTERPOLATE(color[7], INTERPOLATE(color[7], color[3]));
+				else
+					product1a = INTERPOLATE(color[3], color[4]);
+
+				if ((color[4] == color[5]) || (color[7] == color[10]))
+					product2b = INTERPOLATE(color[7], INTERPOLATE(color[7], color[8]));
+				else
+					product2b = INTERPOLATE(color[7], color[8]);
+			}
+			else if (color[3] == color[8] && color[7] != color[4])
+			{
+				product2b = product1a = color[3];
+
+				if ((color[0] == color[3]) || (color[5] == color[9]))
+					product1b = INTERPOLATE(color[3], INTERPOLATE(color[3], color[4]));
+				else
+					product1b = INTERPOLATE(color[3], color[1]);
+
+				if ((color[8] == color[11]) || (color[2] == color[3]))
+					product2a = INTERPOLATE(color[3], INTERPOLATE(color[3], color[2]));
+				else
+					product2a = INTERPOLATE(color[7], color[8]);
+
+			}
+			else if (color[3] == color[8] && color[7] == color[4])
+			{
+				register int r = 0;
+
+				r += GET_RESULT(color[4], color[3], color[6], color[10]);
+				r += GET_RESULT(color[4], color[3], color[2], color[0]);
+				r += GET_RESULT(color[4], color[3], color[11], color[9]);
+				r += GET_RESULT(color[4], color[3], color[1], color[5]);
+
+				if (r > 0)
+				{
+					product1b = product2a = color[7];
+					product1a = product2b = INTERPOLATE(color[3], color[4]);
+				}
+				else if (r < 0)
+				{
+					product2b = product1a = color[3];
+					product1b = product2a = INTERPOLATE(color[3], color[4]);
+				}
+				else
+				{
+					product2b = product1a = color[3];
+					product1b = product2a = color[7];
+				}
+			}
+			else
+			{
+				product2b = product1a = INTERPOLATE(color[7], color[4]);
+				product2b = Q_INTERPOLATE(color[8], color[8], color[8], product2b);
+				product1a = Q_INTERPOLATE(color[3], color[3], color[3], product1a);
+
+				product2a = product1b = INTERPOLATE(color[3], color[8]);
+				product2a = Q_INTERPOLATE(color[7], color[7], color[7], product2a);
+				product1b = Q_INTERPOLATE(color[4], color[4], color[4], product1b);
+			}
+
+			if (PixelsPerMask == 2)
+			{
+				if (ScummPCMode)
+				{
+					SWAP_WORD(product1a);
+					SWAP_WORD(product1b);
+					SWAP_WORD(product2a);
+					SWAP_WORD(product2b);
+				}
+				*((unsigned long *) (&dst_line[0][x * 4])) = (product1a << 16) | product1b;
+				*((unsigned long *) (&dst_line[1][x * 4])) = (product2a << 16) | product2b;
+			}
+			else
+			{
+				*((unsigned long *) (&dst_line[0][x * 8])) = product1a;
+				*((unsigned long *) (&dst_line[0][x * 8 + 4])) = product1b;
+				*((unsigned long *) (&dst_line[1][x * 8])) = product2a;
+				*((unsigned long *) (&dst_line[1][x * 8 + 4])) = product2b;
+			}
+
+			/* Move color matrix forward */
+			color[0] = color[1];
+			color[2] = color[3]; color[3] = color[4]; color[4] = color[5];
+			color[6] = color[7]; color[7] = color[8]; color[8] = color[9];
+			color[10] = color[11];
+
+			if (src_x+x < BufferWidth - 2)
+			{
+				x += 2;
+				if (PixelsPerMask == 2)
+				{
+					color[1] = ScummColors16[ *(src_line[0] + x) ];
+					if (src_x+x < BufferWidth-1)
+					{
+						color[5] = ScummColors16[*(src_line[1]+x+1)];
+						color[9] = ScummColors16[*(src_line[2]+x+1)];
+					}
+					color[11] = ScummColors16[*(src_line[3]+x)];
+				}
+				else
+				{
+					color[1] = ScummColors[*(src_line[0]+x)];
+					if (src_x+x < BufferWidth-1)
+					{
+						color[5] = ScummColors[*(src_line[1]+x+1)];
+						color[9] = ScummColors[ *(src_line[2]+x+1)];
+					}
+					color[11] = ScummColors[*(src_line[3]+x)];
+				}
+				x -= 2;
+			}
+		}
+
+		/* We're done with one line, so we shift the source lines up */
+		src_line[0] = src_line[1];
+		src_line[1] = src_line[2];
+		src_line[2] = src_line[3];
+
+		/* Read next line */
+		if (src_y+y+3 >= BufferHeight)
+			src_line[3] = src_line[2];
+		else
+			src_line[3] = src_line[2] + BufferWidth;
+
+		/* Then shift the color matrix up */
+		if (PixelsPerMask == 2)
+		{
+			byte *sbp;
+			sbp = src_line[0];
+			color[0] = ScummColors16[*sbp];     color[1] = ScummColors16[*(sbp+1)];
+			sbp = src_line[1];
+			color[2] = ScummColors16[*sbp];     color[3] = color[2];    color[4] = ScummColors16[*(sbp+1)];  color[5] = ScummColors16[*(sbp+2)];
+			sbp = src_line[2];
+			color[6] = ScummColors16[*sbp];     color[7] = color[6];    color[8] = ScummColors16[*(sbp+1)];  color[9] = ScummColors16[*(sbp+2)];
+			sbp = src_line[3];
+			color[10] = ScummColors16[*sbp];    color[11] = ScummColors16[*(sbp+1)];
+		}
+		else
+		{
+			byte *lbp;
+			lbp = src_line[0];
+			color[0] = ScummColors[*lbp];     color[1] = ScummColors[*(lbp+1)];
+			lbp = src_line[1];
+			color[2] = ScummColors[*lbp];     color[3] = color[2];    color[4] = ScummColors[*(lbp+1)];  color[5] = ScummColors[*(lbp+2)];
+			lbp = src_line[2];
+			color[6] = ScummColors[*lbp];     color[7] = color[6];    color[8] = ScummColors[*(lbp+1)];  color[9] = ScummColors[*(lbp+2)];
+			lbp = src_line[3];
+			color[10] = ScummColors[*lbp];    color[11] = ScummColors[*(lbp+1)];
+		}
+
+
+		if (src_y + y < BufferHeight - 1)
+		{
+			dst_line[0] = dst_line[1]+dest_pitch;
+			dst_line[1] = dst_line[0]+dest_pitch;
+		}
+	}
+}
+
+void AdvMame2xScaler::Scale(uint32 src_x, uint32 src_y, uint32 dest_x, uint32 dest_y, uint32 width, uint32 height)
+{
+	if (!handle)
+		return;
+
+	byte *src = (byte *)Buffer+src_y*BufferWidth+src_x;
+
+	src_line[0] = src;
+	src_line[1] = src;
+	src_line[2] = src + BufferWidth;
+
+	dst_line[0] = dest+dest_y*2*dest_pitch+dest_x*2*dest_bpp;
+	dst_line[1] = dst_line[0]+dest_pitch;
+
+	for (int y = 0; y < height; y++)
+	{
+		for (int x = 0; x < width; x++)
+		{
+			uint32 B, D, E, F, H;
+
+			if (PixelsPerMask == 2)
+			{
+				// short A = *(src + i - nextlineSrc - 1);
+				B = ScummColors16[src_line[0][x]];
+				// short C = *(src + i - nextlineSrc + 1);
+				D = ScummColors16[src_line[1][x-1]];
+				E = ScummColors16[src_line[1][x]];
+				F = ScummColors16[src_line[1][x+1]];
+				// short G = *(src + i + nextlineSrc - 1);
+				H = ScummColors16[src_line[2][x]];
+				// short I = *(src + i + nextlineSrc + 1);
+			}
+			else
+			{
+				// short A = *(src + i - nextlineSrc - 1);
+				B = ScummColors[src_line[0][x]];
+				// short C = *(src + i - nextlineSrc + 1);
+				D = ScummColors[src_line[1][x-1]];
+				E = ScummColors[src_line[1][x]];
+				F = ScummColors[src_line[1][x+1]];
+				// short G = *(src + i + nextlineSrc - 1);
+				H = ScummColors[src_line[2][x]];
+				// short I = *(src + i + nextlineSrc + 1);
+			}
+
+
+			if (PixelsPerMask == 2)
+			{
+				if (ScummPCMode)
+				{
+					SWAP_WORD(B);
+					SWAP_WORD(D);
+					SWAP_WORD(E);
+					SWAP_WORD(F);
+					SWAP_WORD(H);
+				}
+				*((unsigned long *) (&dst_line[0][x * 4])) = ((D == B && B != F && D != H ? D : E) << 16) | (B == F && B != D && F != H ? F : E);
+				*((unsigned long *) (&dst_line[1][x * 4])) = ((D == H && D != B && H != F ? D : E) << 16) | (H == F && D != H && B != F ? F : E);
+			}
+			else
+			{
+				*((unsigned long *) (&dst_line[0][x * 8])) = D == B && B != F && D != H ? D : E;
+				*((unsigned long *) (&dst_line[0][x * 8 + 4])) = B == F && B != D && F != H ? F : E;
+				*((unsigned long *) (&dst_line[1][x * 8])) = D == H && D != B && H != F ? D : E;
+				*((unsigned long *) (&dst_line[1][x * 8 + 4])) = H == F && D != H && B != F ? F : E;
+			}
+		}
+
+		src_line[0] = src_line[1];
+		src_line[1] = src_line[2];
+		if (src_y+y+2 >= BufferHeight)
+			src_line[2] = src_line[1];
+		else
+			src_line[2] = src_line[1] + BufferWidth;
+
+		if (src_y+y < BufferHeight-1)
+		{
+			dst_line[0] = dst_line[1]+dest_pitch;
+			dst_line[1] = dst_line[0]+dest_pitch;
+		}
+	}
+}
+
+void PointScaler::Scale(uint32 src_x, uint32 src_y, uint32 dest_x, uint32 dest_y, uint32 width, uint32 height)
+{
+	byte *src;
+	uint32 color;
+	uint32 r, g, b;
+	uint32 x, y;
+
+	if (!handle)
+		return;
+
+	src = (byte *)Buffer+src_y*BufferWidth+src_x;
+
+	dst_line[0] = dest+dest_y*2*dest_pitch+dest_x*2*dest_bpp;
+	dst_line[1] = dst_line[0]+dest_pitch;
+
+	for (y = 0; y < height; y++)
+	{
+		for (x = 0; x < width; x++)
+		{
+			r = (ScummColors[*(src+x)] >> 16) & 0xff;
+			g = (ScummColors[*(src+x)] >> 8) & 0xff;
+			b = ScummColors[*(src+x)] & 0xff;
+
+			color = MakeColor(dest_pixfmt, r, g, b);
+			if (PixelsPerMask == 2)
+			{
+				if (ScummPCMode)
+					SWAP_WORD(color);
+
+				*((unsigned long *) (&dst_line[0][x * 4])) = (color << 16) | color;
+				*((unsigned long *) (&dst_line[1][x * 4])) = (color << 16) | color;
+			}
+			else
+			{
+				*((unsigned long *) (&dst_line[0][x * 8])) = color;
+				*((unsigned long *) (&dst_line[0][x * 8 + 4])) = color;
+				*((unsigned long *) (&dst_line[1][x * 8])) = color;
+				*((unsigned long *) (&dst_line[1][x * 8 + 4])) = color;
+			}
+		}
+
+		src += BufferWidth;
+
+		if (src_y+y < BufferHeight-1)
+		{
+			dst_line[0] = dst_line[1]+dest_pitch;
+			dst_line[1] = dst_line[0]+dest_pitch;
+		}
+	}
+}
+
+SCALERTYPE MorphOSScaler::FindByName(const char *ScalerName)
+{
+	int scaler = 0;
+
+	while (ScummScalers[scaler].gs_Name)
+	{
+		if (!stricmp(ScalerName, ScummScalers[scaler].gs_Name))
+			return ScummScalers[scaler].gs_Type;
+		scaler++;
+	}
+
+	if (ScummScalers[scaler].gs_Name == NULL)
+	{
+		puts("Invalid scaler name. Please use one of the following:");
+		for (scaler = 0; ScummScalers[scaler].gs_Name != NULL; scaler++)
+			printf("  %s\n", ScummScalers[scaler].gs_Name);
+	}
+
+	return ST_INVALID;
+}
+
+SCALERTYPE MorphOSScaler::FindByIndex(int index)
+{
+	if (index >= 0 && index < 10 && ScummScalers[index].gs_Name)
+		return ScummScalers[index].gs_Type;
+
+	return ST_INVALID;
+}
+
+const char *MorphOSScaler::GetParamName(SCALERTYPE type)
+{
+	int scaler = 0;
+
+	while (ScummScalers[scaler].gs_Name)
+	{
+		if (ScummScalers[scaler].gs_Type == type)
+			return ScummScalers[scaler].gs_ParamName;
+		scaler++;
+	}
+
+	return NULL;
+}
+
diff --git a/backends/morphos/morphos_scaler.h b/backends/morphos/morphos_scaler.h
new file mode 100644
index 0000000000..c23de6cb8a
--- /dev/null
+++ b/backends/morphos/morphos_scaler.h
@@ -0,0 +1,93 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ */
+
+#ifndef MORPHOS_MORPHOSSCALER_H
+#define MORPHOS_MORPHOSSCALER_H
+
+#include <graphics/gfx.h>
+
+typedef enum { ST_INVALID = 0, ST_NONE, ST_POINT, ST_ADVMAME2X, ST_SUPEREAGLE, ST_SUPER2XSAI } SCALERTYPE;
+
+class MorphOSScaler
+{
+	public:
+		MorphOSScaler(APTR buffer, int width, int height, ULONG *col_table, UWORD *col_table16, BitMap *bmap);
+		virtual ~MorphOSScaler();
+
+		bool Prepare(BitMap *render_bmap);
+		void Finish();
+
+		virtual void Scale(uint32 src_x, uint32 src_y, uint32 dest_x, uint32 dest_y, uint32 width, uint32 height) = 0;
+
+		static MorphOSScaler *Create(SCALERTYPE st, APTR buffer, int width, int height, ULONG *col_table, UWORD *col_table16, BitMap *bmap);
+
+		static SCALERTYPE FindByName(const char *ScalerName);
+		static SCALERTYPE FindByIndex(int index);
+		static const char *GetParamName(SCALERTYPE type);
+
+	protected:
+		struct GfxScaler
+		{
+			STRPTR 		gs_Name;
+			STRPTR 		gs_ParamName;
+			SCALERTYPE	gs_Type;
+		};
+
+		static GfxScaler ScummScalers[11];
+
+		static uint32 MakeColor(int pixfmt, int r, int g, int b);
+
+		byte *dest;
+		uint32 dest_bpp;
+		uint32 dest_pitch;
+		uint32 dest_pixfmt;
+		APTR handle;
+		
+		uint32 colorMask;
+		uint32 lowPixelMask;
+		uint32 qcolorMask;
+		uint32 qlowpixelMask;
+		uint32 redblueMask;
+		uint32 greenMask;
+		int PixelsPerMask;
+		byte *src_line[4];
+		byte *dst_line[2];
+		bool ScummPCMode;
+
+		APTR Buffer;
+		int	BufferWidth;
+		int	BufferHeight;
+		ULONG *ScummColors;
+		USHORT *ScummColors16;
+};
+
+#define DECLARE_SCALER(scaler_name)	class scaler_name ## Scaler : public MorphOSScaler \
+	{ public: scaler_name ## Scaler(APTR buffer, int width, int height, ULONG *col_table, UWORD *col_table16, BitMap *bmap) : MorphOSScaler(buffer, width, height, col_table, col_table16, bmap) {} \
+	  void Scale(uint32 src_x, uint32 src_y, uint32 dest_x, uint32 dest_y, uint32 width, uint32 height); \
+	};
+
+
+DECLARE_SCALER(Point)
+DECLARE_SCALER(AdvMame2x)
+DECLARE_SCALER(SuperEagle)
+DECLARE_SCALER(Super2xSaI)
+
+#endif
+
diff --git a/backends/morphos/morphos_sound.cpp b/backends/morphos/morphos_sound.cpp
new file mode 100644
index 0000000000..0585b8708b
--- /dev/null
+++ b/backends/morphos/morphos_sound.cpp
@@ -0,0 +1,284 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2002 Rüdiger Hanke
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * MorphOS sound support
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "scumm.h"
+
+#include <dos/dos.h>
+#include <exec/memory.h>
+#include <devices/ahi.h>
+#include <devices/amidi.h>
+
+#include <clib/alib_protos.h>
+#include <proto/exec.h>
+#include <proto/dos.h>
+#include <proto/ahi.h>
+
+#include "morphos.h"
+
+#define AHI_BUF_SIZE	 (8*1024)
+
+SignalSemaphore ScummMusicThreadRunning;
+SignalSemaphore ScummSoundThreadRunning;
+
+static MsgPort    *ahiPort    	  = NULL;
+static AHIRequest *ahiReq[2]	   = { NULL, NULL };
+static UWORD		ahiCurBuf		 = 0;
+static bool			ahiReqSent[2] = { false, false };
+static BYTE			ahiDevice		 = -1;
+		 UBYTE		ahiUnit  		 = AHI_DEFAULT_UNIT;
+static char			*ahiBuf[2]	   = { NULL, NULL };
+
+static MsgPort 	   *ScummMidiPort = NULL;
+		 IOMidiRequest *ScummMidiRequest = NULL;
+static MsgPort       *MusicTimerMsgPort = NULL;
+		 timerequest   *MusicTimerIORequest = NULL;
+
+bool init_morphos_music(ULONG MidiUnit)
+{
+	if (ScummMusicDriver && !stricmp(ScummMusicDriver, "-eamidi"))	  // just as ugly as the line below ...
+	{
+		MidiUnit = ScummMidiUnit;	// Ugly fix, but ...
+		ScummMidiPort = CreateMsgPort();
+		if (ScummMidiPort)
+		{
+			ScummMidiRequest = (IOMidiRequest *) CreateIORequest(ScummMidiPort, sizeof (IOMidiRequest));
+			if (ScummMidiRequest)
+			{
+				ScummMidiRequest->amr_Version = 2;
+				if (OpenDevice("amidi.device", MidiUnit, (IORequest *) ScummMidiRequest, AMIDIF_MIDISERVER))
+				{
+					DeleteIORequest((IORequest *) ScummMidiRequest);
+					DeleteMsgPort(ScummMidiPort);
+					ScummMidiRequest = NULL;
+					ScummMidiPort = NULL;
+				}
+			}
+			else
+			{
+				DeleteMsgPort(ScummMidiPort);
+				ScummMidiPort = NULL;
+			}
+		}
+
+		if (!ScummMidiRequest)
+		{
+			warning("Could not open AMidi - music will not play");
+			return false;
+		}
+	}
+
+	MusicTimerMsgPort = CreateMsgPort();
+	if (MusicTimerMsgPort)
+	{
+		MusicTimerIORequest = (timerequest *) CreateIORequest(MusicTimerMsgPort, sizeof (timerequest));
+		if (MusicTimerIORequest)
+		{
+			if (OpenDevice("timer.device", UNIT_MICROHZ, (IORequest *) MusicTimerIORequest, 0))
+			{
+				DeleteIORequest((IORequest *) MusicTimerIORequest);
+				DeleteMsgPort(MusicTimerMsgPort);
+				MusicTimerIORequest = NULL;
+				MusicTimerMsgPort = NULL;
+			}
+		}
+		else
+		{
+			DeleteMsgPort(MusicTimerMsgPort);
+			MusicTimerMsgPort = NULL;
+		}
+	}
+
+	if (!MusicTimerIORequest)
+	{
+		warning("Could not open timer device - music will not play");
+		return false;
+	}
+
+	return true;
+}
+
+
+void exit_morphos_music()
+{
+	if (ScummMidiRequest)
+	{
+		CloseDevice((IORequest *) ScummMidiRequest);
+		DeleteIORequest((IORequest *) ScummMidiRequest);
+		DeleteMsgPort(ScummMidiPort);
+	}
+
+	if (MusicTimerIORequest)
+	{
+		CloseDevice((IORequest *) MusicTimerIORequest);
+		DeleteIORequest((IORequest *) MusicTimerIORequest);
+		DeleteMsgPort(MusicTimerMsgPort);
+	}
+}
+
+
+static bool init_morphos_sound()
+{
+	if (!(ahiPort = CreateMsgPort()))
+		return false;
+
+	if (!(ahiReq[0] = (AHIRequest *) CreateIORequest(ahiPort, sizeof (AHIRequest))))
+	{
+		DeleteMsgPort(ahiPort);
+		ahiPort = NULL;
+		return false;
+	}
+
+	if (!(ahiReq[1] = (AHIRequest *) AllocVec(sizeof (AHIRequest), MEMF_PUBLIC)))
+	{
+		DeleteIORequest(ahiReq[0]);
+		DeleteMsgPort(ahiPort);
+		ahiReq[0] = NULL;
+		ahiPort = NULL;
+		return false;
+	}
+
+	if (!(ahiBuf[0] = (char *) AllocVec(2*AHI_BUF_SIZE, MEMF_PUBLIC)))
+	{
+		FreeVec(ahiReq[1]);
+		DeleteIORequest(ahiReq[0]);
+		DeleteMsgPort(ahiPort);
+		ahiReq[0] = NULL;
+		ahiReq[1] = NULL;
+		ahiPort = NULL;
+		return false;
+	}
+	ahiBuf[1] = &ahiBuf[0][AHI_BUF_SIZE];
+
+	ahiReq[0]->ahir_Version = 4;
+	if (ahiDevice = OpenDevice(AHINAME, 0, (IORequest *) ahiReq[0], 0))
+	{
+		FreeVec(ahiBuf[0]);
+		FreeVec(ahiReq[1]);
+		DeleteIORequest(ahiReq[0]);
+		DeleteMsgPort(ahiPort);
+		ahiBuf[0] = NULL;
+		ahiReq[0] = NULL;
+		ahiReq[1] = NULL;
+		ahiPort = NULL;
+		return false;
+	}
+
+	CopyMem(ahiReq[0], ahiReq[1], sizeof (AHIRequest));
+
+	ahiCurBuf = 0;
+	ahiReqSent[0] = FALSE;
+	ahiReqSent[1] = FALSE;
+
+	return true;
+}
+
+
+static void exit_morphos_sound()
+{
+	if (ahiReq[1])
+		FreeVec(ahiReq[1]);
+
+	if (ahiReq[0])
+	{
+		CloseDevice((IORequest *) ahiReq[0]);
+		DeleteIORequest(ahiReq[0]);
+	}
+
+	if (ahiBuf[0])
+		FreeVec((APTR) ahiBuf[0]);
+
+	if (ahiPort)
+		DeleteMsgPort(ahiPort);
+}
+
+int morphos_sound_thread(OSystem_MorphOS *syst, ULONG SampleType)
+{
+	ULONG signals;
+	bool  initialized;
+
+	ObtainSemaphore(&ScummSoundThreadRunning);
+
+	initialized = init_morphos_sound();
+	if (!initialized)
+	{
+		warning("Sound could not be initialized. The game may hang at some point (press Ctrl-z then).");
+		Wait(SIGBREAKF_CTRL_C);
+	}
+	else
+	{
+		for (;;)
+		{
+			while (!ahiReqSent[ahiCurBuf] || CheckIO((IORequest *) ahiReq[ahiCurBuf]))
+			{
+				AHIRequest *req = ahiReq[ahiCurBuf];
+				UWORD ahiOtherBuf = !ahiCurBuf;
+
+				if (ahiReqSent[ahiCurBuf])
+					WaitIO((IORequest *) req);
+
+				syst->fill_sound((byte *) ahiBuf[ahiCurBuf], AHI_BUF_SIZE);
+	
+				req->ahir_Std.io_Message.mn_Node.ln_Pri = 0;
+				req->ahir_Std.io_Command = CMD_WRITE;
+				req->ahir_Std.io_Data    = ahiBuf[ahiCurBuf];
+				req->ahir_Std.io_Length  = AHI_BUF_SIZE;
+				req->ahir_Type				 = SampleType;
+				req->ahir_Frequency		 = SAMPLES_PER_SEC;
+				req->ahir_Position  		 = 0x8000;
+				req->ahir_Volume			 = 0x10000;
+				req->ahir_Link				 = (ahiReqSent[ahiOtherBuf] && !CheckIO((IORequest *) ahiReq[ahiOtherBuf])) ? ahiReq[ahiOtherBuf] : NULL;
+				SendIO((IORequest *)req);
+
+				ahiReqSent[ahiCurBuf] = true;
+				ahiCurBuf = ahiOtherBuf;
+			}
+
+			signals = Wait(SIGBREAKF_CTRL_C | (1 << ahiPort->mp_SigBit));
+
+			if (signals & SIGBREAKF_CTRL_C)
+				break;
+		}
+
+		if (ahiReqSent[ahiCurBuf])
+		{
+			AbortIO((IORequest *) ahiReq[ahiCurBuf]);
+			WaitIO((IORequest *) ahiReq[ahiCurBuf]);
+			ahiReqSent[ahiCurBuf] = false;
+		}
+
+		if (ahiReqSent[!ahiCurBuf])
+		{
+			AbortIO((IORequest *) ahiReq[!ahiCurBuf]);
+			WaitIO((IORequest *) ahiReq[!ahiCurBuf]);
+			ahiReqSent[!ahiCurBuf] = false;
+		}
+	}
+
+	exit_morphos_sound();
+
+	ReleaseSemaphore(&ScummSoundThreadRunning);
+	RemTask(NULL);
+	return 0;
+}
+
diff --git a/backends/morphos/morphos_start.cpp b/backends/morphos/morphos_start.cpp
new file mode 100644
index 0000000000..d3305cbe14
--- /dev/null
+++ b/backends/morphos/morphos_start.cpp
@@ -0,0 +1,359 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2002 Rüdiger Hanke (MorphOS port)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * MorphOS startup handling
+ *
+ * $Header$
+ *
+ */
+
+#include <exec/types.h>
+#include <exec/devices.h>
+#include <exec/memory.h>
+#include <exec/libraries.h>
+#include <workbench/startup.h>
+#include <workbench/workbench.h>
+
+#include <proto/exec.h>
+#include <proto/dos.h>
+#include <proto/cdda.h>
+#include <proto/cybergraphics.h>
+#include <proto/icon.h>
+
+#include "stdafx.h"
+#include "scumm.h"
+#include "morphos.h"
+#include "morphos_scaler.h"
+
+extern "C" WBStartup *_WBenchMsg;
+
+// For command line parsing
+static STRPTR usageTemplate = "STORY/A,DATAPATH/K,WBWINDOW/S,SCALER/K,AMIGA/S,MIDIUNIT/K/N,MUSIC/K,MUSICVOL/K/N,SFXVOL/K/N,TEMPO/K/N,TALKSPEED/K/N,NOSUBTITLES=NST/S";
+typedef enum { USG_STORY = 0,	 USG_DATAPATH,  USG_WBWINDOW,	 USG_SCALER, 	 USG_AMIGA,	 USG_MIDIUNIT,	 USG_MUSIC,	  USG_MUSICVOL, USG_SFXVOL,    USG_TEMPO,   USG_TALKSPEED, USG_NOSUBTITLES } usageFields;
+static LONG	args[13] =  { (ULONG) NULL, (ULONG) NULL, FALSE, (ULONG) NULL, false, (ULONG) NULL, (ULONG) NULL, (ULONG) NULL, (ULONG) NULL,	(ULONG) NULL, (ULONG) NULL, false };
+static RDArgs *ScummArgs = NULL;
+
+static char*ScummStory = NULL;
+static char*ScummPath = NULL;
+	  STRPTR ScummMusicDriver = NULL;
+		 LONG ScummMidiUnit = 0;
+static LONG ScummMidiVolume = 0;
+static LONG ScummMidiTempo = 0;
+static LONG ScummSfxVolume = 0;
+static LONG ScummTalkSpeed = 0;
+static SCALERTYPE ScummGfxScaler = ST_INVALID;
+
+static BPTR OrigDirLock = 0;
+
+Library *CDDABase = NULL;
+Device *TimerBase = NULL;
+
+OSystem_MorphOS *TheSystem = NULL;
+
+OSystem *OSystem_MorphOS_create(int game_id, int gfx_mode, bool full_screen)
+{
+	if (TheSystem)
+		delete TheSystem;
+
+	SCALERTYPE gfx_scaler = ST_NONE;
+	switch (gfx_mode)
+	{
+		case GFX_DOUBLESIZE:
+			gfx_scaler = ST_POINT;
+			break;
+
+		case GFX_SUPEREAGLE:
+			gfx_scaler = ST_SUPEREAGLE;
+			break;
+
+		case GFX_SUPER2XSAI:
+			gfx_scaler = ST_SUPER2XSAI;
+			break;
+	}
+
+	TheSystem = OSystem_MorphOS::create(game_id, gfx_scaler, full_screen);
+	return TheSystem;
+}
+
+void close_resources()
+{
+	if (TheSystem)
+		delete TheSystem;
+
+	if (g_scumm)
+		delete g_scumm;
+
+	if (ScummPath)
+		FreeVec(ScummPath);
+
+	if (ScummStory)
+		FreeVec(ScummStory);
+
+	if (ScummArgs)
+		FreeArgs(ScummArgs);
+
+	if (OrigDirLock)
+		CurrentDir(OrigDirLock);
+
+	if (CDDABase)
+		CloseLibrary(CDDABase);
+}
+
+static STRPTR FindMusicDriver(STRPTR argval)
+{
+	if (!stricmp(argval, "off"))  	return "-enull";
+	if (!stricmp(argval, "midi"))	 	return "-eamidi";
+	if (!stricmp(argval, "midiemu"))	return "-emidiemu";
+	if (!stricmp(argval, "adlib")) 	return "-eadlib";
+
+	error("No such music driver supported. Possible values are off, Midi, MidiEmu and Adlib.");
+	return NULL;
+}
+
+static void ReadToolTypes(WBArg *OfFile)
+{
+	DiskObject *dobj;
+	char *ToolValue;
+	char IconPath[256];
+
+	NameFromLock(OfFile->wa_Lock, IconPath, 256);
+	AddPart(IconPath, OfFile->wa_Name, 256);
+
+	dobj = GetDiskObject(IconPath);
+	if (dobj == NULL)
+		return;
+
+	if (ToolValue = (char *) FindToolType(dobj->do_ToolTypes, "STORY"))
+	{
+		if (ScummStory)
+			FreeVec(ScummStory);
+		ScummStory = (char *) AllocVec(strlen(ToolValue)+1, MEMF_PUBLIC);
+		strcpy(ScummStory, ToolValue);
+	}
+
+	if (ToolValue = (char *) FindToolType(dobj->do_ToolTypes, "DATAPATH"))
+	{
+		if (ScummPath)
+			FreeVec(ScummPath);
+		ScummPath = (char *) AllocVec(strlen(ToolValue)+4, MEMF_PUBLIC);
+		strcpy(ScummPath, "-p");
+		strcat(ScummPath, ToolValue);
+	}
+
+	if (ToolValue = (char *) FindToolType(dobj->do_ToolTypes, "WBWINDOW"))
+	{
+		if (MatchToolValue(ToolValue, "YES"))
+			args[USG_WBWINDOW] = TRUE;
+		else if (MatchToolValue(ToolValue, "NO"))
+			args[USG_WBWINDOW] = FALSE;
+	}
+
+	if (ToolValue = (char *) FindToolType(dobj->do_ToolTypes, "SCALER"))
+	{
+		if ((ScummGfxScaler = MorphOSScaler::FindByName(ToolValue)) == ST_INVALID)
+		{
+			FreeDiskObject(dobj);
+			exit(1);
+		}
+	}
+
+	if (ToolValue = (char *) FindToolType(dobj->do_ToolTypes, "MUSIC"))
+	{
+		if (!(ScummMusicDriver = FindMusicDriver(ToolValue)))
+		{
+			FreeDiskObject(dobj);
+			exit(1);
+		}
+		args[USG_MUSIC] = (ULONG) &ScummMusicDriver;
+	}
+
+	if( ToolValue = (char *) FindToolType(dobj->do_ToolTypes, "MIDIUNIT"))
+		ScummMidiUnit = atoi(ToolValue);
+
+	if( ToolValue = (char *) FindToolType(dobj->do_ToolTypes, "MUSICVOL"))
+	{
+		int vol = atoi(ToolValue);
+		if (vol >= 0 && vol <= 100)
+		{
+			ScummMidiVolume = vol;
+			args[USG_MUSICVOL] = (ULONG) &ScummMidiVolume;
+		}
+	}
+
+	if (ToolValue = (char *) FindToolType(dobj->do_ToolTypes, "SFXVOL"))
+	{
+		int vol = atoi(ToolValue);
+		if (vol >= 0 && vol <= 255)
+		{
+			ScummSfxVolume = vol;
+			args[USG_SFXVOL] = (ULONG) &ScummSfxVolume;
+		}
+	}
+
+	if (ToolValue = (char *) FindToolType(dobj->do_ToolTypes, "TEMPO"))
+	{
+		ScummMidiTempo = atoi(ToolValue);
+		args[USG_TEMPO] = (ULONG) &ScummMidiTempo;
+	}
+
+	if (ToolValue = (char *) FindToolType(dobj->do_ToolTypes, "TALKSPEED"))
+	{
+		ScummTalkSpeed = atoi(ToolValue);
+		args[USG_TALKSPEED] = (ULONG) &ScummMidiTempo;
+	}
+
+	if (ToolValue = (char *) FindToolType(dobj->do_ToolTypes, "SUBTITLES"))
+	{
+		if (MatchToolValue(ToolValue, "YES"))
+			args[USG_NOSUBTITLES] = FALSE;
+		else if (MatchToolValue(ToolValue, "NO"))
+			args[USG_NOSUBTITLES] = TRUE;
+	}
+
+	if (ToolValue = (char *) FindToolType(dobj->do_ToolTypes, "AMIGA"))
+	{
+		if (MatchToolValue(ToolValue, "YES"))
+			args[USG_AMIGA] = FALSE;
+		else if (MatchToolValue(ToolValue, "NO"))
+			args[USG_AMIGA] = TRUE;
+	}
+
+	FreeDiskObject(dobj);
+}
+
+#undef main
+
+int main()
+{
+	int delta;
+	int last_time, new_time;
+	char *argv[20];
+	char musicvol[6], sfxvol[6], talkspeed[12], tempo[12], scaler[14];
+	int argc = 0;
+
+	InitSemaphore(&ScummSoundThreadRunning);
+	InitSemaphore(&ScummMusicThreadRunning);
+
+	g_scumm = NULL;
+	atexit(&close_resources);
+
+	if (_WBenchMsg == NULL)
+	{
+		/* Parse the command line here */
+		ScummArgs = ReadArgs(usageTemplate, args, NULL);
+		if (ScummArgs == NULL)
+		{
+			puts("Error in command line - type \"ScummVM ?\" for usage.");
+			exit(1);
+		}
+
+		if (args[USG_STORY])
+		{
+			ScummStory = (char *) AllocVec(strlen((char *) args[USG_STORY])+1, MEMF_PUBLIC);
+			strcpy(ScummStory, (char *) args[USG_STORY]);
+		}
+
+		if (args[USG_DATAPATH])
+		{
+			ScummPath = (char *) AllocVec(strlen((char *) args[USG_DATAPATH])+4, MEMF_PUBLIC);
+			strcpy(ScummPath, "-p");
+			strcat(ScummPath, (char *) args[USG_DATAPATH]);
+		}
+
+		if (args[USG_SCALER])
+		{
+			if ((ScummGfxScaler = MorphOSScaler::FindByName((char *) args[USG_SCALER])) == ST_INVALID)
+				exit(1);
+		}
+
+		if (args[USG_MUSIC])
+		{
+			if (!(ScummMusicDriver = FindMusicDriver((char *) args[USG_MUSIC])))
+				exit(1);
+		}
+
+		if (args[USG_MIDIUNIT])
+			ScummMidiUnit = *((LONG *) args[USG_MIDIUNIT]);
+
+		if (args[USG_TEMPO])
+			ScummMidiTempo = *((LONG *) args[USG_TEMPO]);
+
+		if (args[USG_MUSICVOL])
+			ScummMidiVolume = *((LONG *) args[USG_MUSICVOL]);
+
+		if (args[USG_SFXVOL])
+			ScummSfxVolume = *((LONG *) args[USG_SFXVOL]);
+
+		if (args[USG_TALKSPEED])
+			ScummTalkSpeed = *((LONG *) args[USG_TALKSPEED]);
+	}
+	else
+	{
+		/* We've been started from Workbench */
+		ReadToolTypes(&_WBenchMsg->sm_ArgList[0]);
+		if (_WBenchMsg->sm_NumArgs > 1)
+		{
+			ReadToolTypes(&_WBenchMsg->sm_ArgList[1]);
+			OrigDirLock = CurrentDir(_WBenchMsg->sm_ArgList[1].wa_Lock);
+		}
+	}
+
+	if (ScummPath)
+	{
+		char c = ScummPath[strlen(ScummPath)-1];
+		if (c != '/' && c != ':')
+			strcat(ScummPath, "/");
+	}
+
+	argv[argc++] = "ScummVM";
+	if (ScummPath) 				   argv[argc++] = ScummPath;
+	if (!args[ USG_WBWINDOW ]) 	argv[argc++] = "-f";
+	if (args[ USG_NOSUBTITLES ]) 	argv[argc++] = "-n";
+	if (args[ USG_AMIGA ]) 			argv[argc++] = "-a";
+	if (args[ USG_MUSIC ]) 			argv[argc++] = ScummMusicDriver;
+	if (ScummGfxScaler != ST_INVALID)
+	{
+		sprintf(scaler, "-g%s", MorphOSScaler::GetParamName(ScummGfxScaler));
+		argv[argc++] = scaler;
+	}
+	else
+		argv[argc++] = "-gsuper2xsai";
+	if (args[USG_MUSICVOL] && ScummMidiVolume >= 0 && ScummMidiVolume <= 100)
+	{
+		sprintf(musicvol, "-m%d", ScummMidiVolume);
+		argv[argc++] = musicvol;
+	}
+	if (args[USG_SFXVOL] && ScummSfxVolume >= 0 && ScummSfxVolume <= 255)
+	{
+		sprintf(sfxvol, "-s%d", ScummSfxVolume);
+		argv[argc++] = sfxvol;
+	}
+	if (args[USG_TEMPO] && ScummMidiTempo > 0)
+	{
+		sprintf(tempo, "-t%lx", ScummMidiTempo);
+		argv[argc++] = tempo;
+	}
+	if (args[USG_TALKSPEED] && ScummTalkSpeed >= 0 && ScummTalkSpeed <= 255)
+	{
+		sprintf(talkspeed, "-y%d", ScummTalkSpeed);
+		argv[argc++] = talkspeed;
+	}
+	argv[argc++] = ScummStory;
+
+	return morphos_main(argc, argv);
+}
+
diff --git a/backends/morphos/morphos_timer.cpp b/backends/morphos/morphos_timer.cpp
new file mode 100644
index 0000000000..d106b9a1a9
--- /dev/null
+++ b/backends/morphos/morphos_timer.cpp
@@ -0,0 +1,243 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ */
+
+#include "stdafx.h"
+#include "scumm.h"
+
+#include <exec/memory.h>
+#include <exec/semaphores.h>
+#include <dos/dostags.h>
+#include <emul/emulinterface.h>
+
+#include <proto/exec.h>
+#include <proto/dos.h>
+#include <proto/timer.h>
+
+#include "morphos.h"
+#include "timer.h"
+
+static TagItem TimerServiceTags[] = { { NP_Entry,    0 },
+									  { NP_Name, 	 (ULONG)"ScummVM Timer Service" },
+									  { NP_Priority, 20 },
+									  { TAG_DONE,    0 }
+									};
+
+Timer::Timer(Scumm * system)
+{
+	static EmulFunc ThreadEmulFunc;
+
+	InitSemaphore(&TimerServiceSemaphore);
+
+	ThreadEmulFunc.Trap = TRAP_FUNC;
+	ThreadEmulFunc.Address = (ULONG) &TimerService;
+	ThreadEmulFunc.StackSize = 16000;
+	ThreadEmulFunc.Extension = 0;
+	ThreadEmulFunc.Arg1 = (ULONG) this;
+	TimerServiceTags[0].ti_Data = (ULONG) &ThreadEmulFunc;
+	TimerServiceThread = CreateNewProc(TimerServiceTags);
+}
+
+Timer::~Timer()
+{
+	if (TimerServiceThread)
+	{
+		Signal((Task *) TimerServiceThread, SIGBREAKF_CTRL_C);
+		ObtainSemaphore(&TimerServiceSemaphore);
+		ReleaseSemaphore(&TimerServiceSemaphore);
+	}
+}
+
+bool Timer::init()
+{
+	return TimerServiceThread != NULL;
+}
+
+void Timer::release()
+{
+}
+
+bool Timer::installProcedure(int ((*procedure)(int)), int32 interval)
+{
+	return SendMsg(TSM_MSGID_ADDTIMER, procedure, interval);
+}
+
+void Timer::releaseProcedure(int ((*procedure)(int)))
+{
+	SendMsg(TSM_MSGID_REMTIMER, procedure, 0);
+}
+
+bool Timer::SendMsg(ULONG msg_id, int ((*procedure)(int)), LONG interval)
+{
+	if (TimerServiceThread == NULL)
+		return false;
+
+	TimerServiceMessage *tmsg = (TimerServiceMessage *) AllocVec(sizeof (TimerServiceMessage), MEMF_PUBLIC | MEMF_CLEAR);
+	if (tmsg == NULL)
+		return false;
+
+	MsgPort *reply_port = CreateMsgPort();
+	if (reply_port == NULL)
+	{
+		FreeVec(tmsg);
+		return false;
+	}
+
+	tmsg->tsm_Message.mn_Node.ln_Type = NT_MESSAGE;
+	tmsg->tsm_Message.mn_ReplyPort = reply_port;
+	tmsg->tsm_Message.mn_Length = sizeof (TimerServiceMessage);
+	tmsg->tsm_MsgID = msg_id;
+	tmsg->tsm_Callback = procedure;
+	tmsg->tsm_Interval = interval;
+	PutMsg(&TimerServiceThread->pr_MsgPort, tmsg);
+	WaitPort(reply_port);
+	GetMsg(reply_port);
+	
+	FreeVec(tmsg);
+	DeleteMsgPort(reply_port);
+
+	return true;
+}
+
+void Timer::TimerService(Timer *this_ptr)
+{
+	MsgPort *port = &((Process *) FindTask(NULL))->pr_MsgPort;
+	ULONG port_bit = 1 << port->mp_SigBit;
+	ULONG signal_mask = SIGBREAKF_CTRL_C | port_bit;
+	ULONG timer_bits = 0, signals;
+	ULONG interval, t;
+	timeval start_callback, end_callback;
+
+	ULONG timers = 0;
+	TimerSlot timer_slots[MAX_TIMERS];
+
+	ObtainSemaphore(&this_ptr->TimerServiceSemaphore);
+
+	for (;;)
+	{
+		signals = Wait(signal_mask);
+
+		GetSysTime(&start_callback);
+		
+		if (signals & port_bit)
+		{
+			TimerServiceMessage *tmsg;
+
+			while (tmsg = (TimerServiceMessage *) GetMsg(port))
+			{
+				if (tmsg->tsm_Message.mn_Length == sizeof (TimerServiceMessage))
+				{
+					switch (tmsg->tsm_MsgID)
+					{
+						case TSM_MSGID_ADDTIMER:
+							if (timers < MAX_TIMERS)
+							{
+								ULONG unit = UNIT_MICROHZ;
+
+								if (tmsg->tsm_Interval > 1000)
+									unit = UNIT_VBLANK;
+								if (OSystem_MorphOS::OpenATimer(&timer_slots[timers].ts_Port, (IORequest **) &timer_slots[timers].ts_IORequest, unit))
+								{
+									timer_slots[timers].ts_Callback = tmsg->tsm_Callback;
+									timer_slots[timers].ts_Interval = tmsg->tsm_Interval;
+									timer_slots[timers].ts_SignalBit = 1 << timer_slots[timers].ts_Port->mp_SigBit;
+
+									signal_mask |= timer_slots[timers].ts_SignalBit;
+									timer_bits |= timer_slots[timers].ts_SignalBit;
+
+									timerequest *req = timer_slots[timers].ts_IORequest;
+									interval = timer_slots[timers].ts_Interval;
+									req->tr_node.io_Command  = TR_ADDREQUEST;
+									req->tr_time.tv_secs  = interval/1000;
+									req->tr_time.tv_micro = (interval%1000)*1000;
+									SendIO(req);
+
+									timers++;
+								}
+							}
+							break;
+
+						case TSM_MSGID_REMTIMER:
+						{
+							for (t = 0; t < timers; t++)
+							{
+								if (timer_slots[t].ts_Callback == tmsg->tsm_Callback)
+								{
+									AbortIO((IORequest *) timer_slots[t].ts_IORequest);
+									WaitIO((IORequest *) timer_slots[t].ts_IORequest);
+									signal_mask &= ~timer_slots[t].ts_SignalBit;
+									timer_bits &= ~timer_slots[t].ts_SignalBit;
+									DeleteIORequest((IORequest *) timer_slots[t].ts_IORequest);
+									DeleteMsgPort(timer_slots[t].ts_Port);
+									if (t < timers-1)
+										memmove(&timer_slots[t], &timer_slots[t+1], sizeof (TimerSlot)*(timers-t-1));
+									timers--;
+									continue;
+								}
+							}
+							break;
+						}
+
+						default:
+							warning("MorphOS TimerService received message of unknown type.");
+					}
+				}
+
+				ReplyMsg((Message *) tmsg);
+			}
+		}
+
+		if (signals & SIGBREAKF_CTRL_C)
+			break;
+
+		if (signals & timer_bits)
+		{
+			for (t = 0; t < timers; t++)
+			{
+				if (signals & timer_slots[t].ts_SignalBit)
+				{
+					timerequest *req = timer_slots[t].ts_IORequest;
+					WaitIO((IORequest *) req);
+					interval = timer_slots[t].ts_Interval;
+					(*timer_slots[t].ts_Callback)(interval);
+					GetSysTime(&end_callback);
+					SubTime(&end_callback, &start_callback);
+					interval -= end_callback.tv_sec*1000+end_callback.tv_micro/1000+40;
+
+					req->tr_node.io_Command  = TR_ADDREQUEST;
+					req->tr_time.tv_secs  = interval/1000;
+					req->tr_time.tv_micro = (interval%1000)*1000;
+					SendIO(req);
+				}
+			}
+		}
+	}
+
+	for (t = 0; t < timers; t++)
+	{
+		AbortIO((IORequest *) timer_slots[t].ts_IORequest);
+		WaitIO((IORequest *) timer_slots[t].ts_IORequest);
+		DeleteIORequest((IORequest *) timer_slots[t].ts_IORequest);
+		DeleteMsgPort(timer_slots[t].ts_Port);
+	}
+
+	ReleaseSemaphore(&this_ptr->TimerServiceSemaphore);
+	RemTask(NULL);
+}
+
diff --git a/backends/morphos/morphos_timer.h b/backends/morphos/morphos_timer.h
new file mode 100644
index 0000000000..1593b29a5c
--- /dev/null
+++ b/backends/morphos/morphos_timer.h
@@ -0,0 +1,86 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ */
+
+#ifndef MORPHOS_TIMER_H
+#define MORPHOS_TIMER_H
+
+#ifndef TIMER_H
+#include "timer.h"	// for MAX_TIMER
+#endif
+
+#ifndef EXEC_PORTS_H
+#include <exec/ports.h>
+#endif
+
+#ifndef EXEC_IO_H
+#include <exec/io.h>
+#endif
+
+#ifndef EXEC_SEMAPHORES_H
+#include <exec/semaphores.h>
+#endif
+
+#ifndef DOS_DOSEXTENS_H
+#include <dos/dosextens.h>
+#endif
+
+class OSystem;
+
+#define TSM_MSGID_ADDTIMER	  0
+#define TSM_MSGID_REMTIMER    1
+
+struct TimerServiceMessage
+{
+	Message tsm_Message;
+	ULONG tsm_MsgID;
+	int ((*tsm_Callback)(int));
+	LONG tsm_Interval;
+};
+
+class Timer
+{
+	public:
+	   Timer(Scumm * system);
+	   ~Timer();
+
+		bool init();
+		void release();
+		bool installProcedure(int ((*procedure)(int)), int32 interval);
+		void releaseProcedure(int ((*procedure)(int)));
+
+	protected:
+		bool SendMsg(ULONG MsgID, int ((*procedure)(int)), LONG interval);
+		static void TimerService(Timer *);
+
+		Process *TimerServiceThread;
+		SignalSemaphore TimerServiceSemaphore;
+
+		struct TimerSlot
+		{
+			MsgPort *ts_Port;
+			timerequest *ts_IORequest;
+			ULONG ts_SignalBit;
+			int ((*ts_Callback)(int));
+			LONG ts_Interval;
+		};
+};
+
+#endif
+
diff --git a/backends/sdl/fb2opengl.h b/backends/sdl/fb2opengl.h
new file mode 100644
index 0000000000..39ab98ddc5
--- /dev/null
+++ b/backends/sdl/fb2opengl.h
@@ -0,0 +1,355 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ */
+
+// FrameBuffer renderer in an OpenGL texture
+// Andre Souza <asouza@olinux.com.br>
+
+#include <SDL.h>
+#include <SDL_opengl.h>
+#include <stdlib.h>
+#include <string.h>
+
+// FLAGS 
+#define FB2GL_FS 1      // FULLSCREEN
+#define FB2GL_RGBA 2    // Use RGBA (else use palette)
+#define FB2GL_320 4     // 320x256 texture (else use 256x256)
+#define FB2GL_AUDIO 8   // Activate SDL Audio
+#define FB2GL_PITCH 16  // On fb2l_update, use pitch (else bytes per pixel)
+#define FB2GL_EXPAND 32 // Create a RGB fb with the color lookup table
+
+// This extension isn't defined in OpenGL 1.1
+#ifndef GL_EXT_paletted_texture
+#define GL_EXT_paletted_texture 1
+#endif
+
+class FB2GL {
+  private:
+    // Framebuffer for 8 bpp
+    unsigned char ogl_fb[256][256];
+    unsigned char ogl_fbb[256][64];
+    // Framebuffer for RGBA */ 
+    unsigned char ogl_fb1[256][256][4];
+    unsigned char ogl_fb2[256][64][4];
+    // Texture(s)
+    GLuint texture;
+    GLuint textureb;
+    // Display list
+    GLuint dlist;
+    // Color Table (256 colors, RGB)
+    char ogl_ctable[256][3];
+    char ogl_temp_ctable[256][3]; // Support for OpenGL 1.1
+    char flags;
+    void maketex();
+    void makedlist(int xf, int yf);
+    void display();
+
+  public:
+    SDL_Surface *screen;
+    FB2GL() { 
+      flags=0;
+      screen=NULL;
+    }
+    int init(int width, int height, int xfix, int yfix, char _flags);
+    void update(void *fb, int width, int height, int pitch, int xskip, int yskip);
+    void palette(int index, int r, int g, int b);
+    void setPalette(int first, int ncolors);
+};
+
+void FB2GL::maketex()
+{
+  glGenTextures(0,&texture);
+  glBindTexture(GL_TEXTURE_2D,texture);
+
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+
+  // Bilinear filtering
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+/*
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+*/
+  
+  if (flags & FB2GL_RGBA) {
+    glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,256,256,0,GL_RGBA, GL_UNSIGNED_BYTE, ogl_fb1);
+  }
+  else {
+    glTexImage2D(GL_TEXTURE_2D,0,GL_COLOR_INDEX,256,256,0,GL_COLOR_INDEX, GL_UNSIGNED_BYTE, ogl_fb);
+  }
+
+  if (flags & FB2GL_320) {
+    glGenTextures(1,&textureb);
+    glBindTexture(GL_TEXTURE_2D,textureb);
+
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
+
+    // Bilinear filtering
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+/*
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+*/
+
+    if (flags & FB2GL_RGBA) {
+      glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,64,256,0,GL_RGBA, 
+	GL_UNSIGNED_BYTE, ogl_fb2);
+    }
+    else {
+      glTexImage2D(GL_TEXTURE_2D,0,GL_COLOR_INDEX,64,256,0,GL_COLOR_INDEX,
+	GL_UNSIGNED_BYTE, ogl_fbb);
+    }
+  }
+
+}
+
+void FB2GL::makedlist(int xf, int yf)
+{
+  double xfix=(double)xf/128; // 128 = 256/2 (half texture => 0.0 to 1.0)
+  double yfix=(double)yf/128;
+  // End of 256x256 (from -1.0 to 1.0)
+  double texend = (double)96/160; // 160=320/2 (== 0.0), 256-160=96.
+  
+  dlist=glGenLists(1);
+  glNewList(dlist,GL_COMPILE);
+
+  glEnable(GL_TEXTURE_2D);
+
+  glBindTexture(GL_TEXTURE_2D, texture);
+
+  if (!(flags & FB2GL_320)) { // Normal 256x256
+    glBegin(GL_QUADS);
+      glTexCoord2f(0.0,1.0); glVertex2f(-1.0,-1.0-yfix); // upper left 
+      glTexCoord2f(0.0,0.0); glVertex2f(-1.0,1.0); // lower left 
+      glTexCoord2f(1.0,0.0); glVertex2f(1.0+xfix,1.0); // lower right 
+      glTexCoord2f(1.0,1.0); glVertex2f(1.0+xfix,-1.0-yfix); // upper right 
+    glEnd();
+  }
+  else { // 320x256 
+
+    // First, the 256x256 texture 
+    glBegin(GL_QUADS);
+      glTexCoord2f(0.0,1.0); glVertex2f(-1.0,-1.0-yfix); // upper left 
+      glTexCoord2f(0.0,0.0); glVertex2f(-1.0,1.0); // lower left 
+      glTexCoord2f(1.0,0.0); glVertex2f(texend+xfix,1.0); // lower right 
+      glTexCoord2f(1.0,1.0); glVertex2f(texend+xfix,-1.0-yfix); // upper right
+    glEnd();
+
+    // 64x256 
+    glBindTexture(GL_TEXTURE_2D, textureb);
+
+    glBegin(GL_QUADS);
+      glTexCoord2f(0.0,1.0); glVertex2f(texend+xfix,-1.0-yfix); // upper left 
+      glTexCoord2f(0.0,0.0); glVertex2f(texend+xfix,1.0); // lower left 
+      glTexCoord2f(1.0,0.0); glVertex2f(1.0+xfix,1.0); // lower right 
+      glTexCoord2f(1.0,1.0); glVertex2f(1.0+xfix,-1.0-yfix); // upper right 
+    glEnd();
+  }
+
+  glDisable(GL_TEXTURE_2D);
+
+  glEndList();
+}
+
+int FB2GL::init(int width, int height, int xfix, int yfix, char _flags)
+{
+  char gl_ext[4096];
+  gl_ext[0]='\0';
+
+  flags = _flags;
+  
+  // Fullscreen?
+  if ((flags & FB2GL_FS) && !screen) {
+    screen = SDL_SetVideoMode(width, height, 0, SDL_HWSURFACE | SDL_OPENGL | SDL_GL_DOUBLEBUFFER | SDL_FULLSCREEN);
+  }
+  else if (!screen) {
+    screen = SDL_SetVideoMode(width, height, 0, SDL_HWPALETTE | SDL_HWSURFACE | SDL_OPENGL | SDL_GL_DOUBLEBUFFER);
+  }
+
+  if (!screen) {
+    fprintf(stderr, "Couldn't start video res %dx%d\n", width, height);
+    return 0;
+  }
+
+
+  if (!(flags & FB2GL_RGBA)) { // Check for Paletted Texture Extension 
+    
+    strcpy(gl_ext, (char *)glGetString(GL_EXTENSIONS));
+	fprintf(stderr,"gl_ext= %s\n",gl_ext);
+
+    if ( strstr( gl_ext , "GL_EXT_paletted_texture") )
+      glEnable(GL_EXT_paletted_texture);
+    else {
+      fprintf(stderr,"Your OpenGL version doesn't support paletted texture\n");
+      return 0;
+    }
+  }
+  
+  maketex();
+  makedlist(xfix, yfix);
+
+  return 1;
+}
+
+void FB2GL::display()
+{
+  glCallList(dlist);
+  SDL_GL_SwapBuffers();
+}
+
+void FB2GL::update(void *fb, int w, int h, int pitch, int xskip, int yskip) {
+  unsigned char *fb1=(unsigned char *)fb;
+  int x,y,scr_pitch,byte=0;
+
+  if (flags & FB2GL_PITCH) scr_pitch=pitch;
+  else {
+    scr_pitch=w*pitch;
+    byte = pitch; // Bytes perl pixel (for RGBA mode)
+  }
+
+  if (flags & FB2GL_RGBA) {
+    
+    if (flags & FB2GL_EXPAND) { // Expand the 8 bit fb into a RGB fb
+  
+      for (y=yskip; y<h; y++) {
+	for (x=xskip; x<w; x++) {
+	  if (x<256) { 
+	    ogl_fb1[y][x][0] = ogl_ctable[*(fb1+x)][0];
+	    ogl_fb1[y][x][1] = ogl_ctable[*(fb1+x)][1]; 
+	    ogl_fb1[y][x][2] = ogl_ctable[*(fb1+x)][2]; 
+	  }
+	  else {
+	    ogl_fb2[y][x-256][0] = ogl_ctable[*(fb1+x)][0]; 
+	    ogl_fb2[y][x-256][1] = ogl_ctable[*(fb1+x)][1]; 
+	    ogl_fb2[y][x-256][2] = ogl_ctable[*(fb1+x)][2]; 
+	  }
+	}
+	fb1 += scr_pitch;
+      }
+    }
+    else { // No expansion
+      for (y=yskip; y<h; y++) {
+	for (x=xskip; x<w; x++) {
+	  if (x<256) { 
+	    ogl_fb1[y-yskip][x-xskip][0] = *(fb1+(x*byte)); 
+	    ogl_fb1[y-yskip][x-xskip][1] = *(fb1+(x*byte)+1); 
+	    ogl_fb1[y-yskip][x-xskip][2] = *(fb1+(x*byte)+2); 
+	  }
+	  else {
+	    ogl_fb2[y-yskip][x-256][0] = *(fb1+(x*byte)); 
+	    ogl_fb2[y-yskip][x-256][1] = *(fb1+(x*byte)+1); 
+	    ogl_fb2[y-yskip][x-256][2] = *(fb1+(x*byte)+2); 
+	  }
+	}
+	fb1 += scr_pitch;
+      }
+    }
+
+    // Update 256x256 texture
+    glBindTexture(GL_TEXTURE_2D,texture);
+    glFlush();
+    glTexSubImage2D(GL_TEXTURE_2D,0,xskip,yskip,256-xskip,256-yskip,GL_RGBA,
+	GL_UNSIGNED_BYTE,ogl_fb1);
+
+    if (flags & FB2GL_320) {
+      // Update 64x256 texture
+      glBindTexture(GL_TEXTURE_2D,textureb);
+      glFlush();
+      glTexSubImage2D(GL_TEXTURE_2D,0,xskip,yskip,64-xskip,256-yskip,GL_RGBA,
+	GL_UNSIGNED_BYTE,ogl_fb2);
+    }
+
+  }
+  else { // non RGBA (paletted)
+
+    for (y=0; y<h; y++)
+      for (x=0; x<w; x++) {
+	if (x<256) { 
+	  ogl_fb[ y ][ x ] = *(fb1 + (y)*scr_pitch + x);
+	}
+	else { 
+	  ogl_fbb[ y ][ x - 256 ] = *(fb1 + y*scr_pitch + x);
+	}
+      }
+
+    // Update 256x256 texture
+    glBindTexture(GL_TEXTURE_2D,texture);
+    glTexSubImage2D(GL_TEXTURE_2D,0,xskip,yskip,256-xskip,256-yskip,
+	GL_COLOR_INDEX, GL_UNSIGNED_BYTE,ogl_fb);
+		
+    if (flags & FB2GL_320) {
+      // Update 64x256 texture
+      glBindTexture(GL_TEXTURE_2D,textureb);
+      glTexSubImage2D(GL_TEXTURE_2D,0,xskip,yskip,64-xskip,256-yskip,
+	  GL_COLOR_INDEX, GL_UNSIGNED_BYTE,ogl_fbb);
+    }
+
+  }
+
+  display();
+
+}
+
+void FB2GL::palette(int i, int r, int g, int b) {
+  if (flags & FB2GL_EXPAND) {
+    ogl_temp_ctable[i][0]=r;
+    ogl_temp_ctable[i][1]=g;
+    ogl_temp_ctable[i][2]=b;
+  }
+  else { // Paletted texture
+    ogl_ctable[i][0]=r;
+    ogl_ctable[i][1]=g;
+    ogl_ctable[i][2]=b;
+  }
+}
+
+void FB2GL::setPalette(int f, int n) {
+  char temp[256][3];
+  int i;
+ 
+  if (flags & FB2GL_EXPAND) {
+    for (i=f; i<n; i++) {
+      ogl_ctable[i][0] = ogl_temp_ctable[i][0];
+      ogl_ctable[i][1] = ogl_temp_ctable[i][1];
+      ogl_ctable[i][2] = ogl_temp_ctable[i][2];
+    }
+  }
+  else { // Paletted texture
+    glBindTexture(GL_TEXTURE_2D,texture);
+    glGetColorTable(GL_TEXTURE_2D,GL_RGB,GL_UNSIGNED_BYTE,&temp);
+	
+    for (i=f; i<n; i++) {
+      temp[i][0] = ogl_ctable[i][0];
+      temp[i][1] = ogl_ctable[i][1];
+      temp[i][2] = ogl_ctable[i][2];
+    }
+	
+    glColorTable(GL_TEXTURE_2D,GL_RGB,256,GL_RGB,GL_UNSIGNED_BYTE,&temp);
+
+    if (flags & FB2GL_320) {
+      glBindTexture(GL_TEXTURE_2D,textureb);
+      glColorTable(GL_TEXTURE_2D,GL_RGB,256,GL_RGB,GL_UNSIGNED_BYTE,&temp);
+    }
+
+  }
+
+}
diff --git a/backends/sdl/sdl.cpp b/backends/sdl/sdl.cpp
new file mode 100644
index 0000000000..204d1323dd
--- /dev/null
+++ b/backends/sdl/sdl.cpp
@@ -0,0 +1,1409 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "scummsys.h"
+#include "system.h"
+#include "sound/mididrv.h"
+#include "gameDetector.h"
+#include "scaler.h"
+#include "scumm.h"	// Only #included for error() and warning()
+
+#include "scummvm.xpm"
+
+#include <SDL.h>
+#include <SDL_thread.h>
+
+
+class OSystem_SDL : public OSystem {
+public:
+	// Set colors of the palette
+	void set_palette(const byte *colors, uint start, uint num);
+
+	// Set the size of the video bitmap.
+	// Typically, 320x200
+	void init_size(uint w, uint h);
+
+	// Draw a bitmap to screen.
+	// The screen will not be updated to reflect the new bitmap
+	void copy_rect(const byte *buf, int pitch, int x, int y, int w, int h);
+
+	// Update the dirty areas of the screen
+	void update_screen();
+
+	// Either show or hide the mouse cursor
+	bool show_mouse(bool visible);
+	
+	// Set the position of the mouse cursor
+	void set_mouse_pos(int x, int y);
+	
+	// Set the bitmap that's used when drawing the cursor.
+	void set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y);
+	
+	// Shaking is used in SCUMM. Set current shake position.
+	void set_shake_pos(int shake_pos);
+		
+	// Get the number of milliseconds since the program was started.
+	uint32 get_msecs();
+	
+	// Delay for a specified amount of milliseconds
+	void delay_msecs(uint msecs);
+	
+	// Create a thread
+	void *create_thread(ThreadProc *proc, void *param);
+	
+	// Get the next event.
+	// Returns true if an event was retrieved.	
+	bool poll_event(Event *event);
+	
+	// Set function that generates samples 
+	bool set_sound_proc(void *param, SoundProc *proc, byte sound);
+		
+	// Poll cdrom status
+	// Returns true if cd audio is playing
+	bool poll_cdrom();
+
+	// Play cdrom audio track
+	void play_cdrom(int track, int num_loops, int start_frame, int end_frame);
+
+	// Stop cdrom audio track
+	void stop_cdrom();
+
+	// Update cdrom audio status
+	void update_cdrom();
+
+	// Quit
+	void quit();
+
+	// Set a parameter
+	uint32 property(int param, Property *value);
+
+	// Add a callback timer
+	void set_timer(int timer, int (*callback)(int));
+
+	// Mutex handling
+	void *create_mutex(void);
+	void lock_mutex(void *mutex);
+	void unlock_mutex(void *mutex);
+	void delete_mutex(void *mutex);
+
+	static OSystem *create(int gfx_mode, bool full_screen);
+
+private:
+	typedef void TwoXSaiProc(uint8 *srcPtr, uint32 srcPitch, uint8 *deltaPtr,
+								uint8 *dstPtr, uint32 dstPitch, int width, int height);
+
+	SDL_Surface *sdl_screen;      // unseen game screen
+	SDL_Surface *sdl_hwscreen;    // hardware screen
+	SDL_Surface *sdl_tmpscreen;   // temporary screen (for 2xsai)
+	SDL_CD *cdrom;
+
+	enum {
+		DF_WANT_RECT_OPTIM			= 1 << 0,
+		DF_REAL_8BIT				= 1 << 1,
+		DF_SEPARATE_TEMPSCREEN		= 1 << 2,
+		DF_UPDATE_EXPAND_1_PIXEL	= 1 << 3
+	};
+
+	int _mode;
+	bool _full_screen;
+	bool _mouse_visible;
+	bool _mouse_drawn;
+	uint32 _mode_flags;
+
+	bool force_full; //Force full redraw on next update_screen
+	bool cksum_valid;
+
+	enum {
+		NUM_DIRTY_RECT = 100,
+
+		MAX_MOUSE_W = 40,
+		MAX_MOUSE_H = 40,
+		MAX_SCALING = 3
+	};
+
+	int SCREEN_WIDTH, SCREEN_HEIGHT, CKSUM_NUM;
+	SDL_Rect *dirty_rect_list;
+	int num_dirty_rects;
+	uint32 *dirty_checksums;
+
+	int scaling;
+
+	/* CD Audio */
+	int cd_track, cd_num_loops, cd_start_frame, cd_end_frame;
+	Uint32 cd_end_time, cd_stop_time, cd_next_second;
+
+	/* Keyboard mouse emulation */
+	struct KbdMouse {	
+		int16 x, y, x_vel, y_vel, x_max, y_max, x_down_count, y_down_count;
+		uint32 last_time, delay_time, x_down_time, y_down_time;
+	} km;
+
+	struct MousePos {
+		int16 x, y, w, h;
+	};
+
+	byte *_mouse_data;
+	byte *_mouse_backup;
+	MousePos _mouse_cur_state;
+	MousePos _mouse_old_state;
+	int16 _mouse_hotspot_x;
+	int16 _mouse_hotspot_y;
+	int _current_shake_pos;
+	int _new_shake_pos;
+	TwoXSaiProc *_sai_func;
+	SDL_Color *_cur_pal;
+
+	uint _palette_changed_first, _palette_changed_last;
+
+	OSystem_SDL() : _current_shake_pos(0), _new_shake_pos(0) {}
+
+	void add_dirty_rgn_auto(const byte *buf);
+	void mk_checksums(const byte *buf);
+
+	static void fill_sound(void *userdata, Uint8 * stream, int len);
+	
+	void add_dirty_rect(int x, int y, int w, int h);
+
+	void draw_mouse();
+	void undraw_mouse();
+
+	void load_gfx_mode();
+	void unload_gfx_mode();
+
+	void hotswap_gfx_mode();
+
+	void get_320x200_image(byte *buf);	
+
+	void setup_icon();
+	void kbd_mouse();
+};
+
+void atexit_proc() {
+	SDL_ShowCursor(SDL_ENABLE);
+
+	SDL_QuitSubSystem(SDL_INIT_VIDEO);
+	SDL_QuitSubSystem(SDL_INIT_TIMER);
+	SDL_QuitSubSystem(SDL_INIT_CDROM);
+#ifndef WIN32	// FIXME: SDL bug - closing audio freezes w/ waveout
+	SDL_QuitSubSystem(SDL_INIT_AUDIO);
+#endif
+}
+
+OSystem *OSystem_SDL::create(int gfx_mode, bool full_screen) {
+	OSystem_SDL *syst = new OSystem_SDL();
+	syst->_mode = gfx_mode;
+	syst->_full_screen = full_screen;
+
+	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER) ==-1) {
+		error("Could not initialize SDL: %s.\n", SDL_GetError());
+	}
+
+#ifdef WIN32				  /* Use waveout on win32, not */
+	SDL_AudioInit("waveout"); /* dsound - unfortunatly dsound */
+#endif						  /* doesn't do COOPERATIVE mode*/
+
+	SDL_ShowCursor(SDL_DISABLE);
+
+	/* Setup the icon */
+	syst->setup_icon();
+
+	/* Clean up on exit */
+ 	atexit(atexit_proc);
+
+	return syst;
+}
+
+void OSystem_SDL::set_timer(int timer, int (*callback)(int)) {
+	SDL_SetTimer(timer, (SDL_TimerCallback) callback);
+}
+OSystem *OSystem_SDL_create(int gfx_mode, bool full_screen) {
+	return OSystem_SDL::create(gfx_mode, full_screen);
+}
+
+void OSystem_SDL::set_palette(const byte *colors, uint start, uint num) {
+	const byte *b = colors;
+	uint i;
+	SDL_Color *base = _cur_pal + start;
+	for(i=0;i!=num;i++) {
+		base[i].r = b[0];
+		base[i].g = b[1];
+		base[i].b = b[2];
+		b += 4;
+	}
+
+	if (start < _palette_changed_first)
+		_palette_changed_first = start;
+
+	if (start + num > _palette_changed_last)
+		_palette_changed_last = start + num;
+}
+
+void OSystem_SDL::load_gfx_mode() {
+	force_full = true;
+	scaling = 1;
+	_mode_flags = 0;
+
+	_sai_func = NULL;
+	sdl_tmpscreen = NULL;
+	
+	switch(_mode) {
+	case GFX_2XSAI:
+		scaling = 2;
+		_sai_func = _2xSaI;
+		break;
+	case GFX_SUPER2XSAI:
+		scaling = 2;
+		_sai_func = Super2xSaI;
+		break;
+	case GFX_SUPEREAGLE:
+		scaling = 2;
+		_sai_func = SuperEagle;
+		break;
+	case GFX_ADVMAME2X:
+		scaling = 2;
+		_sai_func = AdvMame2x;
+		break;
+
+	case GFX_DOUBLESIZE:
+		scaling = 2;
+		break;
+
+	case GFX_TRIPLESIZE:
+		if (_full_screen) {
+			warning("full screen in useless in triplesize mode, reverting to normal mode");
+			goto normal_mode;
+		}
+		scaling = 3;
+		break;
+
+	case GFX_NORMAL:
+normal_mode:;
+		scaling = 1;
+		break;
+	}
+
+	sdl_screen = SDL_CreateRGBSurface(SDL_SWSURFACE, SCREEN_WIDTH, SCREEN_HEIGHT, 8, 0, 0, 0, 0);
+	if (sdl_screen == NULL)
+		error("sdl_screen failed failed");
+
+	if (_sai_func) {
+		uint16 *tmp_screen = (uint16*)calloc((SCREEN_WIDTH+3)*(SCREEN_HEIGHT+3),sizeof(uint16));
+		_mode_flags = DF_WANT_RECT_OPTIM | DF_SEPARATE_TEMPSCREEN | DF_UPDATE_EXPAND_1_PIXEL;
+
+		sdl_hwscreen = SDL_SetVideoMode(SCREEN_WIDTH * scaling, SCREEN_HEIGHT * scaling, 16, 
+			_full_screen ? (SDL_FULLSCREEN|SDL_SWSURFACE) : SDL_SWSURFACE
+		);
+		if (sdl_hwscreen == NULL)
+			error("sdl_hwscreen failed");
+		
+		/* Need some extra bytes around when using 2XSAI */
+		if (sdl_hwscreen->format->Rmask == 0x7C00)	// HACK HACK HACK
+			Init_2xSaI(555);
+		else
+			Init_2xSaI(565);
+		sdl_tmpscreen = SDL_CreateRGBSurfaceFrom(tmp_screen,
+							SCREEN_WIDTH + 3, SCREEN_HEIGHT + 3, 16, (SCREEN_WIDTH + 3)*2,
+							sdl_hwscreen->format->Rmask,
+							sdl_hwscreen->format->Gmask,
+							sdl_hwscreen->format->Bmask,
+							sdl_hwscreen->format->Amask);
+
+		if (sdl_tmpscreen == NULL)
+			error("sdl_tmpscreen failed");
+		
+	} else {
+		switch(scaling) {
+		case 3:
+			_sai_func = Normal3x;
+			break;
+		case 2:
+			_sai_func = Normal2x;
+			break;
+		case 1:
+			_sai_func = Normal1x;
+			break;
+		}
+
+		_mode_flags = DF_WANT_RECT_OPTIM | DF_REAL_8BIT;
+
+		sdl_hwscreen = SDL_SetVideoMode(SCREEN_WIDTH * scaling, SCREEN_HEIGHT * scaling, 8, 
+			_full_screen ? (SDL_FULLSCREEN|SDL_SWSURFACE) : SDL_SWSURFACE
+		);
+		if (sdl_hwscreen == NULL)
+			error("sdl_hwscreen failed");
+		
+		sdl_tmpscreen = sdl_screen;
+	}
+
+	// keyboard cursor control, some other better place for it?
+	km.x_max = SCREEN_WIDTH * scaling - 1;
+	km.y_max = SCREEN_HEIGHT * scaling - 1;
+	km.delay_time = 25;
+	km.last_time = 0;
+
+}
+
+void OSystem_SDL::unload_gfx_mode() {
+	SDL_FreeSurface(sdl_screen);
+	sdl_screen = NULL; 
+
+	SDL_FreeSurface(sdl_hwscreen); 
+	sdl_hwscreen = NULL;
+
+	if (_mode_flags & DF_SEPARATE_TEMPSCREEN) {
+		free((uint16*)sdl_tmpscreen->pixels);
+		SDL_FreeSurface(sdl_tmpscreen);
+	}
+	sdl_tmpscreen = NULL;
+}
+
+void OSystem_SDL::init_size(uint w, uint h) {
+	//if (w != SCREEN_WIDTH && h != SCREEN_HEIGHT)
+	//	error("320x200 is the only game resolution supported");
+
+	SCREEN_WIDTH = w;
+	SCREEN_HEIGHT = h;
+	CKSUM_NUM = (SCREEN_WIDTH*SCREEN_HEIGHT/(8*8));
+	/* allocate palette, it needs to be persistent across
+	 * driver changes, so i'll alloc it here */
+	_cur_pal = (SDL_Color*)calloc(sizeof(SDL_Color), 256);
+
+	dirty_rect_list = (SDL_Rect*)calloc(NUM_DIRTY_RECT, sizeof(SDL_Rect));
+	_mouse_backup = (byte*)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING);
+	dirty_checksums = (uint32*)calloc(CKSUM_NUM*2, sizeof(uint32));
+
+	load_gfx_mode();
+}
+
+void OSystem_SDL::copy_rect(const byte *buf, int pitch, int x, int y, int w, int h) {
+	if (sdl_screen == NULL)
+		return;
+
+	if (pitch == SCREEN_WIDTH && x==0 && y==0 && w==SCREEN_WIDTH && h==SCREEN_HEIGHT && _mode_flags&DF_WANT_RECT_OPTIM) {
+		/* Special, optimized case for full screen updates.
+		 * It tries to determine what areas were actually changed,
+		 * and just updates those, on the actual display. */
+		add_dirty_rgn_auto(buf);
+	} else {
+		/* Clip the coordinates */
+		if (x < 0) { w+=x; buf-=x; x = 0; }
+		if (y < 0) { h+=y; buf-=y*pitch; y = 0; }
+		if (w > SCREEN_WIDTH-x) { w = SCREEN_WIDTH - x; }
+		if (h > SCREEN_HEIGHT-y) { h = SCREEN_HEIGHT - y; }
+			
+		if (w <= 0 || h <= 0)
+			return;
+
+		cksum_valid = false;
+		add_dirty_rect(x, y, w, h);
+	}
+
+	/* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
+	if (_mouse_drawn)
+		undraw_mouse();
+
+	if (SDL_LockSurface(sdl_screen) == -1)
+		error("SDL_LockSurface failed: %s.\n", SDL_GetError());
+
+	byte *dst = (byte *)sdl_screen->pixels + y * SCREEN_WIDTH + x;
+	do {
+		memcpy(dst, buf, w);
+		dst += SCREEN_WIDTH;
+		buf += pitch;
+	} while (--h);
+
+	SDL_UnlockSurface(sdl_screen);
+}
+
+
+void OSystem_SDL::add_dirty_rect(int x, int y, int w, int h) {
+	if (force_full)
+		return;
+
+	if (num_dirty_rects == NUM_DIRTY_RECT)
+		force_full = true;
+	else {
+		SDL_Rect *r = &dirty_rect_list[num_dirty_rects++];
+		
+		/* Update the dirty region by 1 pixel for graphics drivers
+		 * that "smear" the screen */
+		if (_mode_flags & DF_UPDATE_EXPAND_1_PIXEL) {
+			x--;
+			y--;
+			w+=2;
+			h+=2;
+		}
+
+		/* clip */
+		if (x < 0) { w+=x; x=0; }
+		if (y < 0) { h+=y; y=0; }
+		if (w > SCREEN_WIDTH-x) { w = SCREEN_WIDTH - x; }
+		if (h > SCREEN_HEIGHT-y) { h = SCREEN_HEIGHT - y; }
+	
+		r->x = x;
+		r->y = y;
+		r->w = w;
+		r->h = h;
+	}
+}
+
+#define ROL(a,n) a = (a<<(n)) | (a>>(32-(n)))
+#define DOLINE(x) a ^= ((uint32*)buf)[0+(x)*(SCREEN_WIDTH/4)]; b ^= ((uint32*)buf)[1+(x)*(SCREEN_WIDTH/4)]
+void OSystem_SDL::mk_checksums(const byte *buf) {
+	uint32 *sums = dirty_checksums;
+	uint x,y;
+	const uint last_x = (uint)SCREEN_WIDTH/8;
+	const uint last_y = (uint)SCREEN_HEIGHT/8;
+
+	/* the 8x8 blocks in buf are enumerated starting in the top left corner and
+	 * reading each line at a time from left to right */
+	for(y=0; y != last_y; y++, buf+=SCREEN_WIDTH*(8-1))
+		for(x=0; x != last_x; x++, buf+=8) {
+			uint32 a = x;
+			uint32 b = y;
+
+			DOLINE(0); ROL(a,13); ROL(b,11);
+			DOLINE(2); ROL(a,13); ROL(b,11);
+			DOLINE(4); ROL(a,13); ROL(b,11);
+			DOLINE(6); ROL(a,13); ROL(b,11);
+
+			a*=0xDEADBEEF;
+			b*=0xBAADF00D;
+
+			DOLINE(1); ROL(a,13); ROL(b,11);
+			DOLINE(3); ROL(a,13); ROL(b,11);
+			DOLINE(5); ROL(a,13); ROL(b,11);
+			DOLINE(7); ROL(a,13); ROL(b,11);
+
+			/* output the checksum for this block */
+			*sums++=a+b;
+		}
+}
+#undef DOLINE
+#undef ROL
+
+
+void OSystem_SDL::add_dirty_rgn_auto(const byte *buf) {
+	assert( ((uint32)buf & 3) == 0);
+	
+	/* generate a table of the checksums */
+	mk_checksums(buf);
+
+	if (!cksum_valid) {
+		force_full = true;
+		cksum_valid = true;
+	}
+
+	/* go through the checksum list, compare it with the previous checksums,
+		 and add all dirty rectangles to a list. try to combine small rectangles
+		 into bigger ones in a simple way */
+	if (!force_full) {
+		int x,y,w;
+		uint32 *ck = dirty_checksums;
+		
+		for(y=0; y!=SCREEN_HEIGHT/8; y++) {
+			for(x=0; x!=SCREEN_WIDTH/8; x++,ck++) {
+				if (ck[0] != ck[CKSUM_NUM]) {
+					/* found a dirty 8x8 block, now go as far to the right as possible,
+						 and at the same time, unmark the dirty status by setting old to new. */
+					w=0;
+					do {
+						ck[w+CKSUM_NUM] = ck[w];
+						w++;
+					} while (x+w != SCREEN_WIDTH/8 && ck[w] != ck[w+CKSUM_NUM]);
+					
+					add_dirty_rect(x*8, y*8, w*8, 8);
+
+					if (force_full)
+						goto get_out;
+				}
+			}
+		}
+	} else {
+		get_out:;
+		/* Copy old checksums to new */
+		memcpy(dirty_checksums + CKSUM_NUM, dirty_checksums, CKSUM_NUM * sizeof(uint32));
+	}
+}
+
+void OSystem_SDL::update_screen() {
+	
+	if (sdl_hwscreen == NULL)
+		return;	// Can this really happen?
+
+	/* First make sure the mouse is drawn, if it should be drawn. */
+	draw_mouse();
+	
+	/* Palette update in case we are NOT in "real" 8 bit color mode.
+	 * Must take place before updating the screen, since the palette must
+	 * be set up for conversion from 8bit to 16bit.
+	 */ 
+	if (((_mode_flags & DF_REAL_8BIT) == 0) && _palette_changed_last != 0) {
+		SDL_SetColors(sdl_screen, _cur_pal + _palette_changed_first, 
+			_palette_changed_first,
+			_palette_changed_last - _palette_changed_first);
+		
+		_palette_changed_last = 0;
+
+		force_full = true;
+	}
+
+	
+	/* If the shake position changed, fill the dirty area with blackness */
+	if (_current_shake_pos != _new_shake_pos) {
+		SDL_Rect blackrect = {0, 0, SCREEN_WIDTH*scaling, _new_shake_pos*scaling};
+		SDL_FillRect(sdl_hwscreen, &blackrect, 0);
+
+		_current_shake_pos = _new_shake_pos;
+
+		force_full = true;
+	}
+
+	/* force a full redraw if requested */
+	if (force_full) {
+		num_dirty_rects = 1;
+
+		dirty_rect_list[0].x = 0;
+		dirty_rect_list[0].y = 0;
+		dirty_rect_list[0].w = SCREEN_WIDTH;
+		dirty_rect_list[0].h = SCREEN_HEIGHT;
+	}
+
+	/* Only draw anything if necessary */
+	if (num_dirty_rects > 0) {
+	
+		SDL_Rect *r; 
+		uint32 srcPitch, dstPitch;
+		SDL_Rect *last_rect = dirty_rect_list + num_dirty_rects;
+	
+		/* Convert appropriate parts of the image into 16bpp */
+		if ((_mode_flags & DF_REAL_8BIT) == 0) {
+			SDL_Rect dst;
+			for(r=dirty_rect_list; r!=last_rect; ++r) {
+				dst = *r;
+				dst.x++;
+				dst.y++;
+				if (SDL_BlitSurface(sdl_screen, r, sdl_tmpscreen, &dst) != 0)
+					error("SDL_BlitSurface failed: %s", SDL_GetError());
+			}
+		}
+	
+		SDL_LockSurface(sdl_tmpscreen);
+		SDL_LockSurface(sdl_hwscreen);
+	
+		srcPitch = sdl_tmpscreen->pitch;
+		dstPitch = sdl_hwscreen->pitch;
+	
+		if ((_mode_flags & DF_REAL_8BIT) == 0) {
+			for(r=dirty_rect_list; r!=last_rect; ++r) {
+				register int dst_y = r->y + _current_shake_pos;
+				register int dst_h = 0;
+				if (dst_y < SCREEN_HEIGHT) {
+					dst_h = r->h;
+					if (dst_h > SCREEN_HEIGHT - dst_y)
+						dst_h = SCREEN_HEIGHT - dst_y;
+					
+					r->x <<= 1;
+					dst_y <<= 1;
+					
+					_sai_func((byte*)sdl_tmpscreen->pixels + (r->x+2) + (r->y+1)*srcPitch, srcPitch, NULL, 
+						(byte*)sdl_hwscreen->pixels + r->x*scaling + dst_y*dstPitch, dstPitch, r->w, dst_h);
+				}
+				
+				r->y = dst_y;
+				r->w <<= 1;
+				r->h = dst_h << 1;
+			}
+		} else {
+			for(r=dirty_rect_list; r!=last_rect; ++r) {
+				register int dst_y = r->y + _current_shake_pos;
+				register int dst_h = 0;
+				if (dst_y < SCREEN_HEIGHT) {
+					dst_h = r->h;
+					if (dst_h > SCREEN_HEIGHT - dst_y)
+						dst_h = SCREEN_HEIGHT - dst_y;
+					
+					dst_y *= scaling;
+					
+					_sai_func((byte*)sdl_tmpscreen->pixels + r->x + r->y*srcPitch, srcPitch, NULL, 
+						(byte*)sdl_hwscreen->pixels + r->x*scaling + dst_y*dstPitch, dstPitch, r->w, dst_h);
+				}
+				
+				r->x *= scaling;
+				r->y = dst_y;
+				r->w *= scaling;
+				r->h = dst_h * scaling;
+			}
+		}
+	
+		if (force_full) {
+			dirty_rect_list[0].y = 0;
+			dirty_rect_list[0].h = SCREEN_HEIGHT * scaling;
+		}
+		
+		SDL_UnlockSurface(sdl_tmpscreen);
+		SDL_UnlockSurface(sdl_hwscreen);
+	}
+	
+	/* Palette update in case we are in "real" 8 bit color mode.
+	 * Must take place after the screen data was updated, since with
+	 * "real" 8bit mode, palatte changes may be visible immediatly,
+	 * and we want to avoid any ugly effects.
+	 */
+	if (_mode_flags & DF_REAL_8BIT && _palette_changed_last != 0) {
+		SDL_SetColors(sdl_hwscreen, _cur_pal + _palette_changed_first, 
+			_palette_changed_first,
+			_palette_changed_last - _palette_changed_first);
+		
+		_palette_changed_last = 0;
+	}
+	
+	if (num_dirty_rects > 0) {
+		/* Finally, blit all our changes to the screen */
+		SDL_UpdateRects(sdl_hwscreen, num_dirty_rects, dirty_rect_list);
+	}
+
+	num_dirty_rects = 0;
+	force_full = false;
+}
+
+void OSystem_SDL::kbd_mouse() {
+	uint32 time = get_msecs();
+	if (time >= km.last_time + km.delay_time) {
+		km.last_time = time;
+		if (km.x_down_count == 1) {
+			km.x_down_time = time;
+			km.x_down_count = 2;
+		}
+		if (km.y_down_count == 1) {
+			km.y_down_time = time;      
+			km.y_down_count = 2;
+		}
+
+		if (km.x_vel || km.y_vel) {
+			if (km.x_down_count) {
+				if (time > km.x_down_time + km.delay_time*12) {
+					if (km.x_vel > 0)
+						km.x_vel++;
+					else
+						km.x_vel--;
+				} else if (time > km.x_down_time + km.delay_time*8) {
+					if (km.x_vel > 0)
+						km.x_vel = 5;
+					else
+						km.x_vel = -5;
+				}
+			}
+			if (km.y_down_count) {
+				if (time > km.y_down_time + km.delay_time*12) {
+					if (km.y_vel > 0)
+						km.y_vel++;
+					else
+						km.y_vel--;
+				} else if (time > km.y_down_time + km.delay_time*8) {
+					if (km.y_vel > 0)
+						km.y_vel = 5;
+					else
+						km.y_vel = -5;
+				}
+			}
+
+			km.x += km.x_vel;
+			km.y += km.y_vel;
+
+			if (km.x < 0) {
+				km.x = 0;
+				km.x_vel = -1;
+				km.x_down_count = 1;
+			} else if (km.x > km.x_max) {
+				km.x = km.x_max;
+				km.x_vel = 1;
+				km.x_down_count = 1;
+			}
+
+			if (km.y < 0) {
+				km.y = 0;
+				km.y_vel = -1;
+				km.y_down_count = 1;
+			} else if (km.y > km.y_max) {
+				km.y = km.y_max;
+				km.y_vel = 1;
+				km.y_down_count = 1;
+			}
+
+			SDL_WarpMouse(km.x, km.y);
+		}
+	}
+}
+
+bool OSystem_SDL::show_mouse(bool visible) {
+	if (_mouse_visible == visible)
+		return visible;
+	
+	bool last = _mouse_visible;
+	_mouse_visible = visible;
+
+	if (visible)
+		draw_mouse();
+	else
+		undraw_mouse();
+
+	return last;
+}
+	
+void OSystem_SDL::set_mouse_pos(int x, int y) {
+	if (x != _mouse_cur_state.x || y != _mouse_cur_state.y) {
+		_mouse_cur_state.x = x;
+		_mouse_cur_state.y = y;
+		undraw_mouse();
+	}
+}
+	
+void OSystem_SDL::set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y) {
+	_mouse_cur_state.w = w;
+	_mouse_cur_state.h = h;
+
+	_mouse_hotspot_x = hotspot_x;
+	_mouse_hotspot_y = hotspot_y;
+
+	_mouse_data = (byte*)buf;
+
+	undraw_mouse();
+}
+	
+void OSystem_SDL::set_shake_pos(int shake_pos) {
+	_new_shake_pos = shake_pos;
+}
+		
+uint32 OSystem_SDL::get_msecs() {
+	return SDL_GetTicks();	
+}
+	
+void OSystem_SDL::delay_msecs(uint msecs) {
+	SDL_Delay(msecs);
+}
+	
+void *OSystem_SDL::create_thread(ThreadProc *proc, void *param) {
+	return SDL_CreateThread(proc, param);
+}
+
+int mapKey(int key, byte mod)
+{
+	if (key >= SDLK_F1 && key <= SDLK_F9) {
+		return key - SDLK_F1 + 315;
+	} else if (key >= 'a' && key <= 'z' && mod & KMOD_SHIFT) {
+		key &= ~0x20;
+	} else if (key >= SDLK_NUMLOCK && key <= SDLK_EURO)
+		return 0;
+	return key;
+}
+	
+bool OSystem_SDL::poll_event(Event *event) {
+	SDL_Event ev;
+	kbd_mouse();
+
+	for(;;) {
+		if (!SDL_PollEvent(&ev))
+			return false;
+
+		switch(ev.type) {
+		case SDL_KEYDOWN: {
+				byte b = 0;
+				if (ev.key.keysym.mod & KMOD_SHIFT) b |= KBD_SHIFT;
+				if (ev.key.keysym.mod & KMOD_CTRL) b |= KBD_CTRL;
+				if (ev.key.keysym.mod & KMOD_ALT) b |= KBD_ALT;
+				event->kbd.flags = b;
+	
+				/* internal keypress? */				
+				if (b == KBD_ALT && ev.key.keysym.sym==SDLK_RETURN) {
+					property(PROP_TOGGLE_FULLSCREEN, NULL);
+					break;
+				}
+	
+				if ((b == KBD_CTRL && ev.key.keysym.sym=='z') || (b == KBD_ALT && ev.key.keysym.sym=='x')) {
+					quit();
+					break;
+				}
+				if (b == (KBD_CTRL|KBD_ALT) && 
+					(ev.key.keysym.sym>='1') && (ev.key.keysym.sym<='7')) {
+					Property prop;
+					prop.gfx_mode = ev.key.keysym.sym - '1';
+					property(PROP_SET_GFX_MODE, &prop);
+					break;
+				}
+				#ifdef QTOPIA
+				// quit on fn+backspace on zaurus
+				if (ev.key.keysym.sym==127) {
+					quit();
+					break;
+				}
+				// map menu key (f11) to f5 (scumm menu)
+				if (ev.key.keysym.sym==292) {
+					event->event_code = EVENT_KEYDOWN;
+					event->kbd.keycode = 286;
+					event->kbd.ascii = mapKey(286, ev.key.keysym.mod);
+				}
+				// map center (space) to tab (default action )
+				// i wanted to map the calendar button but the calendar comes up
+				//
+				else if (ev.key.keysym.sym==32) {
+					event->event_code = EVENT_KEYDOWN;
+					event->kbd.keycode = 9;
+					event->kbd.ascii = mapKey(9, ev.key.keysym.mod);
+				}
+				// since we stole space (pause) above we'll rebind it to the tab key on the keyboard
+				else if (ev.key.keysym.sym==9) {
+					event->event_code = EVENT_KEYDOWN;
+					event->kbd.keycode = 32;
+					event->kbd.ascii = mapKey(32, ev.key.keysym.mod);
+				}
+				else {
+				// let the events fall through if we didn't change them, this may not be the best way to
+				// set it up, but i'm not sure how sdl would like it if we let if fall through then redid it though.
+				// and yes i have an huge terminal size so i dont wrap soon enough.
+					event->event_code = EVENT_KEYDOWN;
+					event->kbd.keycode = ev.key.keysym.sym;
+					event->kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod);
+				}
+				#endif
+				#ifndef QTOPIA
+				event->event_code = EVENT_KEYDOWN;
+				event->kbd.keycode = ev.key.keysym.sym;
+				event->kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod);
+				#endif
+				
+				switch(ev.key.keysym.sym) {
+					case SDLK_LEFT:
+						km.x_vel = -1;
+						km.x_down_count = 1;
+					break;
+					case SDLK_RIGHT:
+						km.x_vel =  1;
+						km.x_down_count = 1;
+					break;
+					case SDLK_UP:
+						km.y_vel = -1;
+						km.y_down_count = 1;
+					break;
+					case SDLK_DOWN:
+						km.y_vel =  1;
+						km.y_down_count = 1;
+					break;
+					default:
+					break;
+				}
+	
+				return true;
+			}
+
+		case SDL_KEYUP: {
+				event->event_code = EVENT_KEYUP;
+				event->kbd.keycode = ev.key.keysym.sym;
+				event->kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod);
+
+				switch(ev.key.keysym.sym){
+					case SDLK_LEFT:                
+						if (km.x_vel < 0) {
+							km.x_vel = 0;
+							km.x_down_count = 0;
+						}
+					break;
+					case SDLK_RIGHT:
+						if (km.x_vel > 0) {
+							km.x_vel = 0;
+							km.x_down_count = 0;
+						}
+					break;
+					case SDLK_UP:
+						if (km.y_vel < 0) {
+							km.y_vel = 0;
+							km.y_down_count = 0;
+						}
+					break;
+					case SDLK_DOWN:
+						if (km.y_vel > 0) {
+							km.y_vel = 0;
+							km.y_down_count = 0;
+						}
+					break;
+					default:
+					break;
+				}
+				return true;
+			}
+
+		case SDL_MOUSEMOTION:
+			event->event_code = EVENT_MOUSEMOVE;
+			km.x = event->mouse.x = ev.motion.x;
+			km.y = event->mouse.y = ev.motion.y;
+
+			event->mouse.x /= scaling;
+			event->mouse.y /= scaling;
+
+			return true;
+
+		case SDL_MOUSEBUTTONDOWN:
+			if (ev.button.button == SDL_BUTTON_LEFT)
+				event->event_code = EVENT_LBUTTONDOWN;
+			else if (ev.button.button == SDL_BUTTON_RIGHT)
+				event->event_code = EVENT_RBUTTONDOWN;
+			else
+				break;
+			km.x = event->mouse.x = ev.motion.x;
+			km.y = event->mouse.y = ev.motion.y;
+			event->mouse.x /= scaling;
+			event->mouse.y /= scaling;
+
+			return true;
+
+		case SDL_MOUSEBUTTONUP:
+			if (ev.button.button == SDL_BUTTON_LEFT)
+				event->event_code = EVENT_LBUTTONUP;
+			else if (ev.button.button == SDL_BUTTON_RIGHT)
+				event->event_code = EVENT_RBUTTONUP;
+			else
+				break;
+			event->mouse.x = ev.button.x;
+			event->mouse.y = ev.button.y;
+			event->mouse.x /= scaling;
+			event->mouse.y /= scaling;
+			return true;
+
+		case SDL_QUIT:
+			quit();
+		}
+	}
+}
+	
+bool OSystem_SDL::set_sound_proc(void *param, SoundProc *proc, byte format) {
+	SDL_AudioSpec desired;
+
+	/* only one format supported at the moment */
+
+	desired.freq = SAMPLES_PER_SEC;
+	desired.format = AUDIO_S16SYS;
+	desired.channels = 2;
+	desired.samples = 2048;
+	desired.callback = proc;
+	desired.userdata = param;
+	if (SDL_OpenAudio(&desired, NULL) != 0) {
+		return false;
+	}
+	SDL_PauseAudio(0);
+	return true;
+}
+
+
+/* retrieve the 320x200 bitmap currently being displayed */
+void OSystem_SDL::get_320x200_image(byte *buf) {
+	/* make sure the mouse is gone */
+	undraw_mouse();
+	
+	if (SDL_LockSurface(sdl_screen) == -1)
+		error("SDL_LockSurface failed: %s.\n", SDL_GetError());
+
+	memcpy(buf, sdl_screen->pixels, SCREEN_WIDTH*SCREEN_HEIGHT);
+
+	SDL_UnlockSurface(sdl_screen);
+}
+
+void OSystem_SDL::hotswap_gfx_mode() {
+	/* hmm, need to allocate a 320x200 bitmap
+	 * which will contain the "backup" of the screen during the change.
+	 * then draw that to the new screen right after it's setup.
+	 */
+	
+	byte *bak_mem = (byte*)malloc(SCREEN_WIDTH*SCREEN_HEIGHT);
+
+	get_320x200_image(bak_mem);
+
+	unload_gfx_mode();
+	load_gfx_mode();
+
+	force_full = true;
+
+	/* reset palette */
+	if (_mode_flags & DF_REAL_8BIT)
+		SDL_SetColors(sdl_hwscreen, _cur_pal, 0, 256);
+	else
+		SDL_SetColors(sdl_screen, _cur_pal, 0, 256);
+
+	/* blit image */
+	OSystem_SDL::copy_rect(bak_mem, SCREEN_WIDTH, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
+	free(bak_mem);
+
+	OSystem_SDL::update_screen();
+}
+
+uint32 OSystem_SDL::property(int param, Property *value) {
+	switch(param) {
+
+	case PROP_TOGGLE_FULLSCREEN:
+		_full_screen ^= true;
+
+		if (!SDL_WM_ToggleFullScreen(sdl_hwscreen)) {
+			/* if ToggleFullScreen fails, achieve the same effect with hotswap gfx mode */
+			hotswap_gfx_mode();
+		}
+		return 1;
+
+	case PROP_GET_FULLSCREEN:
+		return _full_screen;
+
+	case PROP_SET_WINDOW_CAPTION:
+		SDL_WM_SetCaption(value->caption, value->caption);
+		return 1;
+
+	case PROP_OPEN_CD:
+		if (SDL_InitSubSystem(SDL_INIT_CDROM) == -1)
+			cdrom = NULL;
+		else {
+			cdrom = SDL_CDOpen(value->cd_num);
+			/* Did if open? Check if cdrom is NULL */
+			if (!cdrom) {
+				warning("Couldn't open drive: %s\n", SDL_GetError());
+			}
+		}
+		break;
+
+	case PROP_SET_GFX_MODE:
+		if (value->gfx_mode >= 7)
+			return 0;
+
+		_mode = value->gfx_mode;
+		hotswap_gfx_mode();
+
+		return 1;
+
+	case PROP_SHOW_DEFAULT_CURSOR:
+		SDL_ShowCursor(value->show_cursor ? SDL_ENABLE : SDL_DISABLE);		
+		break;
+
+	case PROP_GET_SAMPLE_RATE:
+		return SAMPLES_PER_SEC;
+	}
+
+	return 0;
+}
+		
+void OSystem_SDL::quit() {
+  if(cdrom) {
+    SDL_CDStop(cdrom);
+    SDL_CDClose(cdrom);
+  }
+	unload_gfx_mode();		
+	exit(1);
+}
+
+void OSystem_SDL::draw_mouse() {
+	if (_mouse_drawn || !_mouse_visible)
+		return;
+
+	int x = _mouse_cur_state.x - _mouse_hotspot_x;
+	int y = _mouse_cur_state.y - _mouse_hotspot_y;
+	int w = _mouse_cur_state.w;
+	int h = _mouse_cur_state.h;
+	byte color;
+	byte *src = _mouse_data;		// Image representing the mouse
+	byte *bak = _mouse_backup;		// Surface used to backup the area obscured by the mouse
+	byte *dst;					// Surface we are drawing into
+
+	// clip the mouse rect, and addjust the src pointer accordingly
+	if (x < 0) {
+		w += x;
+		src -= x;
+		x = 0;
+	}
+	if (y < 0) {
+		h += y;
+		src -= y * _mouse_cur_state.w;
+		y = 0;
+	}
+	if (w > SCREEN_WIDTH - x)
+		w = SCREEN_WIDTH - x;
+	if (h > SCREEN_HEIGHT - y)
+		h = SCREEN_HEIGHT - y;
+
+	// Store the bounding box so that undraw mouse can restore the area the
+	// mouse currently covers to its original content.
+	_mouse_old_state.x = x;
+	_mouse_old_state.y = y;
+	_mouse_old_state.w = w;
+	_mouse_old_state.h = h;
+
+	// Quick check to see if anything has to be drawn at all
+	if (w <= 0 || h <= 0)
+		return;
+
+	// Draw the mouse cursor; backup the covered area in "bak"
+
+	if (SDL_LockSurface(sdl_screen) == -1)
+		error("SDL_LockSurface failed: %s.\n", SDL_GetError());
+
+	add_dirty_rect(x, y, w, h);
+
+	dst = (byte *)sdl_screen->pixels + y * SCREEN_WIDTH + x;
+	while (h > 0) {
+		int width = w;
+		while (width > 0) {
+			*bak++ = *dst;
+			color = *src++;
+			if (color != 0xFF)	// 0xFF = transparent, don't draw
+				*dst = color;
+			dst++;
+			width--;
+		}
+		src += _mouse_cur_state.w - w;
+		bak += MAX_MOUSE_W - w;
+		dst += SCREEN_WIDTH - w;
+		h--;
+	}
+
+	SDL_UnlockSurface(sdl_screen);
+	
+	// Finally, set the flag to indicate the mouse has been drawn
+	_mouse_drawn = true;
+}
+
+void OSystem_SDL::undraw_mouse() {
+	if (!_mouse_drawn)
+		return;
+	_mouse_drawn = false;
+
+	if (SDL_LockSurface(sdl_screen) == -1)
+		error("SDL_LockSurface failed: %s.\n", SDL_GetError());
+
+	byte *dst, *bak = _mouse_backup;
+	const int old_mouse_x = _mouse_old_state.x;
+	const int old_mouse_y = _mouse_old_state.y;
+	const int old_mouse_w = _mouse_old_state.w;
+	const int old_mouse_h = _mouse_old_state.h;
+	int x,y;
+
+	// No need to do clipping here, since draw_mouse() did that already
+
+	dst = (byte *)sdl_screen->pixels + old_mouse_y * SCREEN_WIDTH + old_mouse_x;
+	for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += SCREEN_WIDTH) {
+		for (x = 0; x < old_mouse_w; ++x) {
+			dst[x] = bak[x];
+		}
+	}
+
+	add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h);
+
+	SDL_UnlockSurface(sdl_screen);
+}
+
+void OSystem_SDL::stop_cdrom() {	/* Stop CD Audio in 1/10th of a second */
+	cd_stop_time = SDL_GetTicks() + 100;
+	cd_num_loops = 0;
+
+}
+
+void OSystem_SDL::play_cdrom(int track, int num_loops, int start_frame, int end_frame) {
+	if (!num_loops && !start_frame)
+		return;
+
+	if (!cdrom)
+		return;
+	
+	if (end_frame > 0)
+		end_frame+=5;
+
+	cd_track = track;
+	cd_num_loops = num_loops;
+	cd_start_frame = start_frame;
+
+	SDL_CDStatus(cdrom);	
+	SDL_CDPlayTracks(cdrom, track, start_frame, 0, end_frame);
+	cd_end_frame = end_frame;
+	cd_stop_time = 0;
+	cd_end_time = SDL_GetTicks() + cdrom->track[track].length * 1000 / CD_FPS;
+}
+
+bool OSystem_SDL::poll_cdrom() {
+	if (!cdrom)
+		return false;
+
+	return (cd_num_loops != 0 && (SDL_GetTicks() < cd_end_time || SDL_CDStatus(cdrom) != CD_STOPPED));
+}
+
+void OSystem_SDL::update_cdrom() {
+	if (!cdrom)
+		return;
+		
+	if (cd_stop_time != 0 && SDL_GetTicks() >= cd_stop_time) {
+		SDL_CDStop(cdrom);
+		cd_num_loops = 0;
+		cd_stop_time = 0;
+		return;
+	}
+
+	if (cd_num_loops == 0 || SDL_GetTicks() < cd_end_time)
+		return;
+
+	if (cd_num_loops != 1 && SDL_CDStatus(cdrom) != CD_STOPPED) {
+		// Wait another second for it to be done
+		cd_end_time += 1000;
+		return;
+	}
+
+	if (cd_num_loops > 0)
+		cd_num_loops--;
+
+	if (cd_num_loops != 0) {
+		SDL_CDPlayTracks(cdrom, cd_track, cd_start_frame, 0, cd_end_frame);
+		cd_end_time = SDL_GetTicks() + cdrom->track[cd_track].length * 1000 / CD_FPS;
+	}
+}
+
+void OSystem_SDL::setup_icon() {
+	int w, h, ncols, nbytes, i;
+	unsigned int rgba[256], icon[32 * 32];
+	unsigned char mask[32][4];
+
+	sscanf(scummvm_icon[0], "%d %d %d %d", &w, &h, &ncols, &nbytes);
+	if ((w != 32) || (h != 32) || (ncols > 255) || (nbytes > 1)) {
+		warning("Could not load the icon (%d %d %d %d)", w, h, ncols, nbytes);
+		return;
+	}
+	for (i = 0; i < ncols; i++) {
+		unsigned char code;
+		char color[32];
+		unsigned int col;
+		sscanf(scummvm_icon[1 + i], "%c c %s", &code, color);
+		if (!strcmp(color, "None"))
+			col = 0x00000000;
+		else if (!strcmp(color, "black"))
+			col = 0xFF000000;
+		else if (color[0] == '#') {
+			sscanf(color + 1, "%06x", &col);
+			col |= 0xFF000000;
+		} else {
+			warning("Could not load the icon (%d %s - %s) ", code, color, scummvm_icon[1 + i]);
+			return;
+		}
+		
+		rgba[code] = col;
+	}
+	memset(mask, 0, sizeof(mask));
+	for (h = 0; h < 32; h++) {
+		char *line = scummvm_icon[1 + ncols + h];
+		for (w = 0; w < 32; w++) {
+			icon[w + 32 * h] = rgba[line[w]];
+			if (rgba[line[w]] & 0xFF000000) {
+				mask[h][w >> 3] |= 1 << (7 - (w & 0x07));
+			}
+		}
+	}
+
+	SDL_Surface *sdl_surf = SDL_CreateRGBSurfaceFrom(icon, 32, 32, 32, 32 * 4, 0xFF0000, 0x00FF00, 0x0000FF, 0xFF000000);
+	SDL_WM_SetIcon(sdl_surf, (unsigned char *) mask);
+}
+
+void *OSystem_SDL::create_mutex(void) {
+	return (void *) SDL_CreateMutex();
+}
+
+void OSystem_SDL::lock_mutex(void *mutex) {
+	SDL_mutexP((SDL_mutex *) mutex);
+}
+
+void OSystem_SDL::unlock_mutex(void *mutex) {
+	SDL_mutexV((SDL_mutex *) mutex);
+}
+
+void OSystem_SDL::delete_mutex(void *mutex) {
+	SDL_DestroyMutex((SDL_mutex *) mutex);
+}
+
+
+#ifdef USE_NULL_DRIVER
+
+/* NULL video driver */
+class OSystem_NULL : public OSystem {
+public:
+	void set_palette(const byte *colors, uint start, uint num) {}
+	void init_size(uint w, uint h);
+	void copy_rect(const byte *buf, int pitch, int x, int y, int w, int h) {}
+	void update_screen() {}
+	bool show_mouse(bool visible) { return false; }
+	void set_mouse_pos(int x, int y) {}
+	void set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y) {}
+	void set_shake_pos(int shake_pos) {}
+	uint32 get_msecs();
+	void delay_msecs(uint msecs);
+	void *create_thread(ThreadProc *proc, void *param) { return NULL; }
+	bool poll_event(Event *event) { return false; }
+	bool set_sound_proc(void *param, SoundProc *proc, byte sound) {}
+	void quit() { exit(1); }
+	uint32 property(int param, Property *value) { return 0; }
+	static OSystem *create(int gfx_mode, bool full_screen);
+private:
+
+	uint msec_start;
+
+	uint32 get_ticks();
+};
+
+void OSystem_NULL::init_size(uint w, uint h, byte sound) {
+	msec_start = get_ticks();
+}
+
+uint32 OSystem_NULL::get_ticks() {
+	uint a = 0;
+#ifdef WIN32
+	a = GetTickCount();
+#endif
+#ifdef UNIX
+	struct timeval tv;
+	gettimeofday(&tv, NULL);
+	a = tv.tv_sec * 1000 + tv.tv_usec/1000;
+#endif
+
+	return a;
+}
+
+void OSystem_NULL::delay_msecs(uint msecs) {
+#ifdef WIN32
+	Sleep(msecs);
+#endif
+#ifdef UNIX
+	usleep(msecs*1000);
+#endif
+}
+
+uint32 OSystem_NULL::get_msecs() {
+	return get_ticks() - msec_start;
+}
+
+OSystem *OSystem_NULL_create() {
+	return new OSystem_NULL();
+}
+#else /* USE_NULL_DRIVER */
+
+OSystem *OSystem_NULL_create() {
+	return NULL;
+}
+
+#endif
diff --git a/backends/sdl/sdl_gl.cpp b/backends/sdl/sdl_gl.cpp
new file mode 100644
index 0000000000..adec2a1f6b
--- /dev/null
+++ b/backends/sdl/sdl_gl.cpp
@@ -0,0 +1,1068 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include "scummsys.h"
+#include "system.h"
+#include "sound/mididrv.h"
+#include "gameDetector.h"
+#include "scaler.h"
+#include "scumm.h"	// Only #included for error() and warning()
+
+#include "scummvm.xpm"
+
+#include <SDL.h>
+#include <SDL_thread.h>
+
+#ifdef WIN32
+int glColorTable(int, int, int, int, int, void *) { return 0; }
+int glGetColorTable(int, int, int, void *) { return 0; }
+/* Use OpenGL 1.1 */
+bool OGL_1_1 = true;
+#else
+bool OGL_1_1 = false;
+#endif
+
+#include "fb2opengl.h"
+FB2GL fb2gl;
+
+class OSystem_SDL : public OSystem {
+public:
+	// Set colors of the palette
+	void set_palette(const byte *colors, uint start, uint num);
+
+	// Set the size of the video bitmap.
+	// Typically, 320x200
+	void init_size(uint w, uint h);
+
+	// Draw a bitmap to screen.
+	// The screen will not be updated to reflect the new bitmap
+	void copy_rect(const byte *buf, int pitch, int x, int y, int w, int h);
+
+	// Update the dirty areas of the screen
+	void update_screen();
+
+	// Either show or hide the mouse cursor
+	bool show_mouse(bool visible);
+	
+	// Set the position of the mouse cursor
+	void set_mouse_pos(int x, int y);
+	
+	// Set the bitmap that's used when drawing the cursor.
+	void set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y);
+	
+	// Shaking is used in SCUMM. Set current shake position.
+	void set_shake_pos(int shake_pos);
+		
+	// Get the number of milliseconds since the program was started.
+	uint32 get_msecs();
+	
+	// Delay for a specified amount of milliseconds
+	void delay_msecs(uint msecs);
+	
+	// Create a thread
+	void *create_thread(ThreadProc *proc, void *param);
+	
+	// Get the next event.
+	// Returns true if an event was retrieved.	
+	bool poll_event(Event *event);
+	
+	// Set function that generates samples 
+	bool set_sound_proc(void *param, SoundProc *proc, byte sound);
+		
+	// Poll cdrom status
+	// Returns true if cd audio is playing
+	bool poll_cdrom();
+
+	// Play cdrom audio track
+	void play_cdrom(int track, int num_loops, int start_frame, int end_frame);
+
+	// Stop cdrom audio track
+	void stop_cdrom();
+
+	// Update cdrom audio status
+	void update_cdrom();
+
+	// Quit
+	void quit();
+
+	// Set a parameter
+	uint32 property(int param, Property *value);
+
+	// Add a callback timer
+	void set_timer(int timer, int (*callback)(int));
+
+	// Mutex handling
+	void *create_mutex(void);
+	void lock_mutex(void *mutex);
+	void unlock_mutex(void *mutex);
+	void delete_mutex(void *mutex);
+
+	static OSystem *create(int gfx_mode, bool full_screen);
+
+private:
+	typedef void TwoXSaiProc(uint8 *srcPtr, uint32 srcPitch, uint8 *deltaPtr,
+								uint8 *dstPtr, uint32 dstPitch, int width, int height);
+
+	SDL_Surface *sdl_screen;
+	SDL_Surface *sdl_tmpscreen;
+	SDL_CD *cdrom;
+
+	enum {
+		DF_WANT_RECT_OPTIM			= 1 << 0,
+		DF_REAL_8BIT				= 1 << 1,
+		DF_SEPARATE_TEMPSCREEN		= 1 << 2,
+		DF_UPDATE_EXPAND_1_PIXEL	= 1 << 3
+	};
+
+	int _mode;
+	bool _full_screen;
+	bool _mouse_visible;
+	bool _mouse_drawn;
+	uint32 _mode_flags;
+
+	bool force_full; //Force full redraw on next update_screen
+	bool cksum_valid;
+
+	enum {
+		NUM_DIRTY_RECT = 100,
+
+		MAX_MOUSE_W = 40,
+		MAX_MOUSE_H = 40,
+		MAX_SCALING = 3
+	};
+
+	int SCREEN_WIDTH, SCREEN_HEIGHT, CKSUM_NUM;
+	SDL_Rect *dirty_rect_list;
+	int num_dirty_rects;
+	uint32 *dirty_checksums;
+
+	int scaling;
+
+	/* CD Audio */
+	int cd_track, cd_num_loops, cd_start_frame, cd_end_frame;
+	Uint32 cd_end_time, cd_stop_time, cd_next_second;
+
+	struct MousePos {
+		int16 x, y, w, h;
+	};
+
+	byte *_mouse_data;
+	byte *_mouse_backup;
+	MousePos _mouse_cur_state;
+	MousePos _mouse_old_state;
+	int16 _mouse_hotspot_x;
+	int16 _mouse_hotspot_y;
+	int _current_shake_pos;
+	int _new_shake_pos;
+	TwoXSaiProc *_sai_func;
+	SDL_Color *_cur_pal;
+
+	uint _palette_changed_first, _palette_changed_last;
+
+	OSystem_SDL() : _current_shake_pos(0), _new_shake_pos(0) {}
+
+	void add_dirty_rgn_auto(const byte *buf);
+	void mk_checksums(const byte *buf);
+
+	static void fill_sound(void *userdata, Uint8 * stream, int len);
+	
+	void add_dirty_rect(int x, int y, int w, int h);
+
+	void draw_mouse();
+	void undraw_mouse();
+
+	void load_gfx_mode();
+	void unload_gfx_mode();
+
+	void hotswap_gfx_mode();
+
+	void get_320x200_image(byte *buf);	
+
+	void setup_icon();
+};
+
+bool atexit_proc_instaled = false;
+void atexit_proc() {
+	SDL_ShowCursor(SDL_ENABLE);
+	SDL_Quit();
+}
+
+OSystem *OSystem_SDL::create(int gfx_mode, bool full_screen) {
+	OSystem_SDL *syst = new OSystem_SDL();
+	syst->_mode = gfx_mode;
+	syst->_full_screen = full_screen;
+
+	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER) ==-1) {
+		error("Could not initialize SDL: %s.\n", SDL_GetError());
+	}
+
+#ifdef WIN32				  /* Use waveout on win32, not */
+	SDL_AudioInit("waveout"); /* dsound - unfortunatly dsound */
+#endif						  /* doesn't do COOPERATIVE mode*/
+
+	SDL_ShowCursor(SDL_DISABLE);
+
+	/* Setup the icon */
+	syst->setup_icon();
+
+#ifndef MACOSX		// Work around a bug in OS X
+	/* Clean up on exit */
+	atexit_proc_instaled = true;
+ 	atexit(atexit_proc);
+#endif
+
+	return syst;
+}
+
+void OSystem_SDL::set_timer(int timer, int (*callback)(int)) {
+	SDL_SetTimer(timer, (SDL_TimerCallback) callback);
+}
+OSystem *OSystem_SDL_create(int gfx_mode, bool full_screen) {
+	return OSystem_SDL::create(gfx_mode, full_screen);
+}
+
+void OSystem_SDL::set_palette(const byte *colors, uint start, uint num) {
+	const byte *b = colors;
+	uint i;
+
+	for(i=0;i!=num;i++) {
+	    fb2gl.palette(i+start,b[0],b[1],b[2]);
+	    b += 4;
+	}
+
+	if (start < _palette_changed_first)
+		_palette_changed_first = start;
+
+	if (start + num > _palette_changed_last)
+		_palette_changed_last = start + num;
+}
+
+void OSystem_SDL::load_gfx_mode() {
+	int gl_flags =  FB2GL_320 | FB2GL_PITCH; 
+	force_full = true;
+	scaling = 1;
+	_mode_flags = 0;
+
+	_sai_func = NULL;
+	sdl_tmpscreen = NULL;
+
+	/* It's easier to work with 8 bit (256 colors) */
+	_mode_flags |= DF_REAL_8BIT;
+	
+	sdl_screen = SDL_CreateRGBSurface(SDL_SWSURFACE, SCREEN_WIDTH, SCREEN_HEIGHT, 8, 0, 0, 0, 0);
+	if (sdl_screen == NULL)
+		error("sdl_screen failed failed");
+
+	_sai_func = Normal1x;
+
+	_mode_flags = DF_WANT_RECT_OPTIM | DF_REAL_8BIT;
+
+	if (_full_screen) gl_flags |= (FB2GL_FS);
+	
+	if (OGL_1_1) { // OpenGL 1.1
+	  gl_flags |= (FB2GL_RGBA | FB2GL_EXPAND);
+	  fb2gl.init(640,480,0,70,gl_flags );
+	}
+	else { // OpenGL 1.2
+	  if (!fb2gl.init(640,480,0,70,gl_flags)) { // Try to use 8bpp textures
+	    gl_flags |= (FB2GL_RGBA | FB2GL_EXPAND); // using RGBA textures
+	    fb2gl.init(640,480,0,70,gl_flags);	
+	  }
+	}
+
+#ifdef MACOSX		// Work around a bug in OS X
+	if (!atexit_proc_instaled) {
+		atexit_proc_instaled = true;
+		atexit(atexit_proc);
+	}
+#endif
+
+	SDL_SetGamma(1.25,1.25,1.25);
+	  
+	sdl_tmpscreen = sdl_screen;
+}
+
+void OSystem_SDL::unload_gfx_mode() {
+	SDL_FreeSurface(sdl_screen);
+	sdl_screen = NULL; 
+
+	if (_mode_flags & DF_SEPARATE_TEMPSCREEN) {
+		free((uint16*)sdl_tmpscreen->pixels);
+		SDL_FreeSurface(sdl_tmpscreen);
+	}
+	sdl_tmpscreen = NULL;
+}
+
+void OSystem_SDL::init_size(uint w, uint h) {
+	//if (w != SCREEN_WIDTH && h != SCREEN_HEIGHT)
+	//	error("320x200 is the only game resolution supported");
+
+	SCREEN_WIDTH = w;
+	SCREEN_HEIGHT = h;
+	CKSUM_NUM = (SCREEN_WIDTH*SCREEN_HEIGHT/(8*8));
+	/* allocate palette, it needs to be persistent across
+	 * driver changes, so i'll alloc it here */
+	_cur_pal = (SDL_Color*)calloc(sizeof(SDL_Color), 256);
+
+	dirty_rect_list = (SDL_Rect*)calloc(NUM_DIRTY_RECT, sizeof(SDL_Rect));
+	_mouse_backup = (byte*)malloc(MAX_MOUSE_W * MAX_MOUSE_H * MAX_SCALING);
+	dirty_checksums = (uint32*)calloc(CKSUM_NUM*2, sizeof(uint32));
+
+	load_gfx_mode();
+}
+
+void OSystem_SDL::copy_rect(const byte *buf, int pitch, int x, int y, int w, int h) {
+	if (sdl_screen == NULL)
+		return;
+
+	if (pitch == SCREEN_WIDTH && x==0 && y==0 && w==SCREEN_WIDTH && h==SCREEN_HEIGHT && _mode_flags&DF_WANT_RECT_OPTIM) {
+		/* Special, optimized case for full screen updates.
+		 * It tries to determine what areas were actually changed,
+		 * and just updates those, on the actual display. */
+		add_dirty_rgn_auto(buf);
+	} else {
+		/* Clip the coordinates */
+		if (x < 0) { w+=x; buf-=x; x = 0; }
+		if (y < 0) { h+=y; buf-=y*pitch; y = 0; }
+		if (w > SCREEN_WIDTH-x) { w = SCREEN_WIDTH - x; }
+		if (h > SCREEN_HEIGHT-y) { h = SCREEN_HEIGHT - y; }
+			
+		if (w <= 0 || h <= 0)
+			return;
+
+		cksum_valid = false;
+		add_dirty_rect(x, y, w, h);
+	}
+
+	/* FIXME: undraw mouse only if the draw rect intersects with the mouse rect */
+	if (_mouse_drawn)
+		undraw_mouse();
+
+	if (SDL_LockSurface(sdl_screen) == -1)
+		error("SDL_LockSurface failed: %s.\n", SDL_GetError());
+
+	byte *dst = (byte *)sdl_screen->pixels + y * SCREEN_WIDTH + x;
+	do {
+		memcpy(dst, buf, w);
+		dst += SCREEN_WIDTH;
+		buf += pitch;
+	} while (--h);
+
+	SDL_UnlockSurface(sdl_screen);
+}
+
+
+void OSystem_SDL::add_dirty_rect(int x, int y, int w, int h) {
+	if (force_full)
+		return;
+
+	if (num_dirty_rects == NUM_DIRTY_RECT)
+		force_full = true;
+	else {
+		SDL_Rect *r = &dirty_rect_list[num_dirty_rects++];
+		
+		/* Update the dirty region by 1 pixel for graphics drivers
+		 * that "smear" the screen */
+		if (_mode_flags & DF_UPDATE_EXPAND_1_PIXEL) {
+			x--;
+			y--;
+			w+=2;
+			h+=2;
+		}
+
+		/* clip */
+		if (x < 0) { w+=x; x=0; }
+		if (y < 0) { h+=y; y=0; }
+		if (w > SCREEN_WIDTH-x) { w = SCREEN_WIDTH - x; }
+		if (h > SCREEN_HEIGHT-y) { h = SCREEN_HEIGHT - y; }
+	
+		r->x = x;
+		r->y = y;
+		r->w = w;
+		r->h = h;
+	}
+}
+
+#define ROL(a,n) a = (a<<(n)) | (a>>(32-(n)))
+#define DOLINE(x) a ^= ((uint32*)buf)[0+(x)*(SCREEN_WIDTH/4)]; b ^= ((uint32*)buf)[1+(x)*(SCREEN_WIDTH/4)]
+void OSystem_SDL::mk_checksums(const byte *buf) {
+	uint32 *sums = dirty_checksums;
+	uint x,y;
+	const uint last_x = (uint)SCREEN_WIDTH/8;
+	const uint last_y = (uint)SCREEN_HEIGHT/8;
+
+	/* the 8x8 blocks in buf are enumerated starting in the top left corner and
+	 * reading each line at a time from left to right */
+	for(y=0; y != last_y; y++, buf+=SCREEN_WIDTH*(8-1))
+		for(x=0; x != last_x; x++, buf+=8) {
+			uint32 a = x;
+			uint32 b = y;
+
+			DOLINE(0); ROL(a,13); ROL(b,11);
+			DOLINE(2); ROL(a,13); ROL(b,11);
+			DOLINE(4); ROL(a,13); ROL(b,11);
+			DOLINE(6); ROL(a,13); ROL(b,11);
+
+			a*=0xDEADBEEF;
+			b*=0xBAADF00D;
+
+			DOLINE(1); ROL(a,13); ROL(b,11);
+			DOLINE(3); ROL(a,13); ROL(b,11);
+			DOLINE(5); ROL(a,13); ROL(b,11);
+			DOLINE(7); ROL(a,13); ROL(b,11);
+
+			/* output the checksum for this block */
+			*sums++=a+b;
+		}
+}
+#undef DOLINE
+#undef ROL
+
+
+void OSystem_SDL::add_dirty_rgn_auto(const byte *buf) {
+	assert( ((uint32)buf & 3) == 0);
+	
+	/* generate a table of the checksums */
+	mk_checksums(buf);
+
+	if (!cksum_valid) {
+		force_full = true;
+		cksum_valid = true;
+	}
+
+	/* go through the checksum list, compare it with the previous checksums,
+		 and add all dirty rectangles to a list. try to combine small rectangles
+		 into bigger ones in a simple way */
+	if (!force_full) {
+		int x,y,w;
+		uint32 *ck = dirty_checksums;
+		
+		for(y=0; y!=SCREEN_HEIGHT/8; y++) {
+			for(x=0; x!=SCREEN_WIDTH/8; x++,ck++) {
+				if (ck[0] != ck[CKSUM_NUM]) {
+					/* found a dirty 8x8 block, now go as far to the right as possible,
+						 and at the same time, unmark the dirty status by setting old to new. */
+					w=0;
+					do {
+						ck[w+CKSUM_NUM] = ck[w];
+						w++;
+					} while (x+w != SCREEN_WIDTH/8 && ck[w] != ck[w+CKSUM_NUM]);
+					
+					add_dirty_rect(x*8, y*8, w*8, 8);
+
+					if (force_full)
+						goto get_out;
+				}
+			}
+		}
+	} else {
+		get_out:;
+		/* Copy old checksums to new */
+		memcpy(dirty_checksums + CKSUM_NUM, dirty_checksums, CKSUM_NUM * sizeof(uint32));
+	}
+}
+
+void OSystem_SDL::update_screen() {
+
+	/* First make sure the mouse is drawn, if it should be drawn. */
+	draw_mouse();
+	
+	/* If the shake position changed, fill the dirty area with blackness */
+	if (_current_shake_pos != _new_shake_pos) {
+
+		_current_shake_pos = _new_shake_pos;
+
+	}
+
+	/* Palette update in case we are in "real" 8 bit color mode.
+	 * Must take place after the screen data was updated, since with
+	 * "real" 8bit mode, palatte changes may be visible immediatly,
+	 * and we want to avoid any ugly effects.
+	 */
+	if (_palette_changed_last != 0) {
+                fb2gl.setPalette(_palette_changed_first, 
+		    _palette_changed_last - _palette_changed_first);
+		
+		_palette_changed_last = 0;
+	}
+
+	fb2gl.update(sdl_tmpscreen->pixels,320,200,320,0,_current_shake_pos);
+
+}
+
+bool OSystem_SDL::show_mouse(bool visible) {
+	if (_mouse_visible == visible)
+		return visible;
+	
+	bool last = _mouse_visible;
+	_mouse_visible = visible;
+
+	if (visible)
+		draw_mouse();
+	else
+		undraw_mouse();
+
+	return last;
+}
+	
+void OSystem_SDL::set_mouse_pos(int x, int y) {
+	if (x != _mouse_cur_state.x || y != _mouse_cur_state.y) {
+		_mouse_cur_state.x = x;
+		_mouse_cur_state.y = y;
+		undraw_mouse();
+	}
+}
+	
+void OSystem_SDL::set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y) {
+	_mouse_cur_state.w = w;
+	_mouse_cur_state.h = h;
+
+	_mouse_hotspot_x = hotspot_x;
+	_mouse_hotspot_y = hotspot_y;
+
+	_mouse_data = (byte*)buf;
+
+	undraw_mouse();
+}
+	
+void OSystem_SDL::set_shake_pos(int shake_pos) {
+	_new_shake_pos = shake_pos;
+}
+		
+uint32 OSystem_SDL::get_msecs() {
+	return SDL_GetTicks();	
+}
+	
+void OSystem_SDL::delay_msecs(uint msecs) {
+	SDL_Delay(msecs);
+}
+	
+void *OSystem_SDL::create_thread(ThreadProc *proc, void *param) {
+	return SDL_CreateThread(proc, param);
+}
+
+int mapKey(int key, byte mod)
+{
+	if (key >= SDLK_F1 && key <= SDLK_F9) {
+		return key - SDLK_F1 + 315;
+	} else if (key >= 'a' && key <= 'z' && mod & KMOD_SHIFT) {
+		key &= ~0x20;
+	} else if (key >= SDLK_NUMLOCK && key <= SDLK_EURO)
+		return 0;
+	return key;
+}
+	
+bool OSystem_SDL::poll_event(Event *event) {
+	SDL_Event ev;
+
+	for(;;) {
+		if (!SDL_PollEvent(&ev))
+			return false;
+
+		switch(ev.type) {
+		case SDL_KEYDOWN: {
+				byte b = 0;
+				if (ev.key.keysym.mod & KMOD_SHIFT) b |= KBD_SHIFT;
+				if (ev.key.keysym.mod & KMOD_CTRL) b |= KBD_CTRL;
+				if (ev.key.keysym.mod & KMOD_ALT) b |= KBD_ALT;
+				event->kbd.flags = b;
+
+				/* internal keypress? */				
+				if (b == KBD_ALT && ev.key.keysym.sym==SDLK_RETURN) {
+					property(PROP_TOGGLE_FULLSCREEN, NULL);
+					break;
+				}
+
+				if ((b == KBD_CTRL && ev.key.keysym.sym=='z') || (b == KBD_ALT && ev.key.keysym.sym=='x')) {
+					quit();
+					break;
+				}
+
+				if (b == (KBD_CTRL|KBD_ALT) && 
+				    (ev.key.keysym.sym>='1') && (ev.key.keysym.sym<='7')) {
+					Property prop;
+					prop.gfx_mode = ev.key.keysym.sym - '1';
+					property(PROP_SET_GFX_MODE, &prop);
+					break;
+				}
+
+
+				event->event_code = EVENT_KEYDOWN;
+				event->kbd.keycode = ev.key.keysym.sym;
+				event->kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod);
+				return true;
+			}
+
+		case SDL_KEYUP: 
+			event->event_code = EVENT_KEYUP;
+			event->kbd.keycode = ev.key.keysym.sym;
+			event->kbd.ascii = mapKey(ev.key.keysym.sym, ev.key.keysym.mod);
+
+			return true;
+
+		case SDL_MOUSEMOTION:
+			event->event_code = EVENT_MOUSEMOVE;
+			event->mouse.x = ev.motion.x;
+			event->mouse.y = ev.motion.y;
+
+			event->mouse.x /= scaling;
+			event->mouse.y /= scaling;
+
+			return true;
+
+		case SDL_MOUSEBUTTONDOWN:
+			if (ev.button.button == SDL_BUTTON_LEFT)
+				event->event_code = EVENT_LBUTTONDOWN;
+			else if (ev.button.button == SDL_BUTTON_RIGHT)
+				event->event_code = EVENT_RBUTTONDOWN;
+			else
+				break;
+			event->mouse.x = ev.button.x;
+			event->mouse.y = ev.button.y;
+			event->mouse.x /= scaling;
+			event->mouse.y /= scaling;
+
+			return true;
+
+		case SDL_MOUSEBUTTONUP:
+			if (ev.button.button == SDL_BUTTON_LEFT)
+				event->event_code = EVENT_LBUTTONUP;
+			else if (ev.button.button == SDL_BUTTON_RIGHT)
+				event->event_code = EVENT_RBUTTONUP;
+			else
+				break;
+			event->mouse.x = ev.button.x;
+			event->mouse.y = ev.button.y;
+			event->mouse.x /= scaling;
+			event->mouse.y /= scaling;
+			return true;
+
+		case SDL_QUIT:
+			quit();
+		}
+	}
+}
+	
+bool OSystem_SDL::set_sound_proc(void *param, SoundProc *proc, byte format) {
+	SDL_AudioSpec desired;
+
+	/* only one format supported at the moment */
+
+	desired.freq = SAMPLES_PER_SEC;
+	desired.format = AUDIO_S16SYS;
+	desired.channels = 2;
+	desired.samples = 2048;
+	desired.callback = proc;
+	desired.userdata = param;
+	if (SDL_OpenAudio(&desired, NULL) != 0) {
+		return false;
+	}
+	SDL_PauseAudio(0);
+	return true;
+}
+
+
+/* retrieve the 320x200 bitmap currently being displayed */
+void OSystem_SDL::get_320x200_image(byte *buf) {
+	/* make sure the mouse is gone */
+	undraw_mouse();
+	
+	if (SDL_LockSurface(sdl_screen) == -1)
+		error("SDL_LockSurface failed: %s.\n", SDL_GetError());
+
+	memcpy(buf, sdl_screen->pixels, SCREEN_WIDTH*SCREEN_HEIGHT);
+
+	SDL_UnlockSurface(sdl_screen);
+}
+
+void OSystem_SDL::hotswap_gfx_mode() {
+	/* hmm, need to allocate a 320x200 bitmap
+	 * which will contain the "backup" of the screen during the change.
+	 * then draw that to the new screen right after it's setup.
+	 */
+	
+	byte *bak_mem = (byte*)malloc(SCREEN_WIDTH*SCREEN_HEIGHT);
+
+	get_320x200_image(bak_mem);
+
+	unload_gfx_mode();
+	load_gfx_mode();
+
+	fb2gl.setPalette(0,256);
+	fb2gl.update(sdl_tmpscreen->pixels,320,200,320,0,_current_shake_pos);
+
+	/* blit image */
+	OSystem_SDL::copy_rect(bak_mem, SCREEN_WIDTH, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
+	free(bak_mem);
+
+	OSystem_SDL::update_screen();
+}
+
+uint32 OSystem_SDL::property(int param, Property *value) {
+	switch(param) {
+
+	case PROP_TOGGLE_FULLSCREEN:
+		_full_screen ^= true;
+		SDL_WM_ToggleFullScreen(fb2gl.screen);
+		return 1;
+
+	case PROP_GET_FULLSCREEN:
+		return _full_screen;
+
+	case PROP_SET_WINDOW_CAPTION:
+		SDL_WM_SetCaption(value->caption, value->caption);
+		return 1;
+
+	case PROP_OPEN_CD:
+		if (SDL_InitSubSystem(SDL_INIT_CDROM) == -1)
+			cdrom = NULL;
+		else {
+			cdrom = SDL_CDOpen(value->cd_num);
+			/* Did if open? Check if cdrom is NULL */
+			if (!cdrom) {
+				warning("Couldn't open drive: %s\n", SDL_GetError());
+			}
+		}
+		break;
+
+	case PROP_SET_GFX_MODE:
+		if (value->gfx_mode >= 7)
+			return 0;
+
+		_mode = value->gfx_mode;
+		hotswap_gfx_mode();
+
+		return 1;
+
+	case PROP_SHOW_DEFAULT_CURSOR:
+		SDL_ShowCursor(value->show_cursor ? SDL_ENABLE : SDL_DISABLE);		
+		break;
+
+	case PROP_GET_SAMPLE_RATE:
+		return SAMPLES_PER_SEC;
+	}
+
+	return 0;
+}
+		
+void OSystem_SDL::quit() {
+	if(cdrom) {
+		SDL_CDStop(cdrom);
+		SDL_CDClose(cdrom);
+	}
+	unload_gfx_mode();		
+	exit(1);
+}
+
+void OSystem_SDL::draw_mouse() {
+	if (_mouse_drawn || !_mouse_visible)
+		return;
+
+	int x = _mouse_cur_state.x - _mouse_hotspot_x;
+	int y = _mouse_cur_state.y - _mouse_hotspot_y;
+	int w = _mouse_cur_state.w;
+	int h = _mouse_cur_state.h;
+	byte color;
+	byte *src = _mouse_data;		// Image representing the mouse
+	byte *bak = _mouse_backup;		// Surface used to backup the area obscured by the mouse
+	byte *dst;					// Surface we are drawing into
+
+	// clip the mouse rect, and addjust the src pointer accordingly
+	if (x < 0) {
+		w += x;
+		src -= x;
+		x = 0;
+	}
+	if (y < 0) {
+		h += y;
+		src -= y * _mouse_cur_state.w;
+		y = 0;
+	}
+	if (w > SCREEN_WIDTH - x)
+		w = SCREEN_WIDTH - x;
+	if (h > SCREEN_HEIGHT - y)
+		h = SCREEN_HEIGHT - y;
+
+	// Store the bounding box so that undraw mouse can restore the area the
+	// mouse currently covers to its original content.
+	_mouse_old_state.x = x;
+	_mouse_old_state.y = y;
+	_mouse_old_state.w = w;
+	_mouse_old_state.h = h;
+
+	// Quick check to see if anything has to be drawn at all
+	if (w <= 0 || h <= 0)
+		return;
+
+	// Draw the mouse cursor; backup the covered area in "bak"
+
+	if (SDL_LockSurface(sdl_screen) == -1)
+		error("SDL_LockSurface failed: %s.\n", SDL_GetError());
+
+	add_dirty_rect(x, y, w, h);
+
+	dst = (byte *)sdl_screen->pixels + y * SCREEN_WIDTH + x;
+	while (h > 0) {
+		int width = w;
+		while (width > 0) {
+			*bak++ = *dst;
+			color = *src++;
+			if (color != 0xFF)	// 0xFF = transparent, don't draw
+				*dst = color;
+			dst++;
+			width--;
+		}
+		src += _mouse_cur_state.w - w;
+		bak += MAX_MOUSE_W - w;
+		dst += SCREEN_WIDTH - w;
+		h--;
+	}
+
+	SDL_UnlockSurface(sdl_screen);
+	
+	// Finally, set the flag to indicate the mouse has been drawn
+	_mouse_drawn = true;
+}
+
+void OSystem_SDL::undraw_mouse() {
+	if (!_mouse_drawn)
+		return;
+	_mouse_drawn = false;
+
+	if (SDL_LockSurface(sdl_screen) == -1)
+		error("SDL_LockSurface failed: %s.\n", SDL_GetError());
+
+	byte *dst, *bak = _mouse_backup;
+	const int old_mouse_x = _mouse_old_state.x;
+	const int old_mouse_y = _mouse_old_state.y;
+	const int old_mouse_w = _mouse_old_state.w;
+	const int old_mouse_h = _mouse_old_state.h;
+	int x,y;
+
+	// No need to do clipping here, since draw_mouse() did that already
+
+	dst = (byte *)sdl_screen->pixels + old_mouse_y * SCREEN_WIDTH + old_mouse_x;
+	for (y = 0; y < old_mouse_h; ++y, bak += MAX_MOUSE_W, dst += SCREEN_WIDTH) {
+		for (x = 0; x < old_mouse_w; ++x) {
+			dst[x] = bak[x];
+		}
+	}
+
+	add_dirty_rect(old_mouse_x, old_mouse_y, old_mouse_w, old_mouse_h);
+
+	SDL_UnlockSurface(sdl_screen);
+}
+
+void OSystem_SDL::stop_cdrom() {	/* Stop CD Audio in 1/10th of a second */
+	cd_stop_time = SDL_GetTicks() + 100;
+	cd_num_loops = 0;
+
+}
+
+void OSystem_SDL::play_cdrom(int track, int num_loops, int start_frame, int end_frame) {
+	if (!num_loops && !start_frame)
+		return;
+
+	if (!cdrom)
+		return;
+	
+	if (end_frame > 0)
+		end_frame+=5;
+
+	cd_track = track;
+	cd_num_loops = num_loops;
+	cd_start_frame = start_frame;
+
+	SDL_CDStatus(cdrom);	
+	SDL_CDPlayTracks(cdrom, track, start_frame, 0, end_frame);
+	cd_end_frame = end_frame;
+	cd_stop_time = 0;
+	cd_end_time = SDL_GetTicks() + cdrom->track[track].length * 1000 / CD_FPS;
+}
+
+bool OSystem_SDL::poll_cdrom() {
+	if (!cdrom)
+		return false;
+
+	return (cd_num_loops != 0 && (SDL_GetTicks() < cd_end_time || SDL_CDStatus(cdrom) != CD_STOPPED));
+}
+
+void OSystem_SDL::update_cdrom() {
+	if (!cdrom)
+		return;
+		
+	if (cd_stop_time != 0 && SDL_GetTicks() >= cd_stop_time) {
+		SDL_CDStop(cdrom);
+		cd_num_loops = 0;
+		cd_stop_time = 0;
+		return;
+	}
+
+	if (cd_num_loops == 0 || SDL_GetTicks() < cd_end_time)
+		return;
+
+	if (cd_num_loops != 1 && SDL_CDStatus(cdrom) != CD_STOPPED) {
+		// Wait another second for it to be done
+		cd_end_time += 1000;
+		return;
+	}
+
+	if (cd_num_loops > 0)
+		cd_num_loops--;
+
+	if (cd_num_loops != 0) {
+		SDL_CDPlayTracks(cdrom, cd_track, cd_start_frame, 0, cd_end_frame);
+		cd_end_time = SDL_GetTicks() + cdrom->track[cd_track].length * 1000 / CD_FPS;
+	}
+}
+
+void OSystem_SDL::setup_icon() {
+	int w, h, ncols, nbytes, i;
+	unsigned int rgba[256], icon[32 * 32];
+	unsigned char mask[32][4];
+
+	sscanf(scummvm_icon[0], "%d %d %d %d", &w, &h, &ncols, &nbytes);
+	if ((w != 32) || (h != 32) || (ncols > 255) || (nbytes > 1)) {
+		warning("Could not load the icon (%d %d %d %d)", w, h, ncols, nbytes);
+		return;
+	}
+	for (i = 0; i < ncols; i++) {
+		unsigned char code;
+		char color[32];
+		unsigned int col;
+		sscanf(scummvm_icon[1 + i], "%c c %s", &code, color);
+		if (!strcmp(color, "None"))
+			col = 0x00000000;
+		else if (!strcmp(color, "black"))
+			col = 0xFF000000;
+		else if (color[0] == '#') {
+			sscanf(color + 1, "%06x", &col);
+			col |= 0xFF000000;
+		} else {
+			warning("Could not load the icon (%d %s - %s) ", code, color, scummvm_icon[1 + i]);
+			return;
+		}
+		
+		rgba[code] = col;
+	}
+	memset(mask, 0, sizeof(mask));
+	for (h = 0; h < 32; h++) {
+		char *line = scummvm_icon[1 + ncols + h];
+		for (w = 0; w < 32; w++) {
+			icon[w + 32 * h] = rgba[line[w]];
+			if (rgba[line[w]] & 0xFF000000) {
+				mask[h][w >> 3] |= 1 << (7 - (w & 0x07));
+			}
+		}
+	}
+
+	SDL_Surface *sdl_surf = SDL_CreateRGBSurfaceFrom(icon, 32, 32, 32, 32 * 4, 0xFF0000, 0x00FF00, 0x0000FF, 0xFF000000);
+	SDL_WM_SetIcon(sdl_surf, (unsigned char *) mask);
+}
+
+void *OSystem_SDL::create_mutex(void) {
+	return (void *) SDL_CreateMutex();
+}
+
+void OSystem_SDL::lock_mutex(void *mutex) {
+	SDL_mutexP((SDL_mutex *) mutex);
+}
+
+void OSystem_SDL::unlock_mutex(void *mutex) {
+	SDL_mutexV((SDL_mutex *) mutex);
+}
+
+void OSystem_SDL::delete_mutex(void *mutex) {
+	SDL_DestroyMutex((SDL_mutex *) mutex);
+}
+
+
+#ifdef USE_NULL_DRIVER
+
+/* NULL video driver */
+class OSystem_NULL : public OSystem {
+public:
+	void set_palette(const byte *colors, uint start, uint num) {}
+	void init_size(uint w, uint h);
+	void copy_rect(const byte *buf, int pitch, int x, int y, int w, int h) {}
+	void update_screen() {}
+	bool show_mouse(bool visible) { return false; }
+	void set_mouse_pos(int x, int y) {}
+	void set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y) {}
+	void set_shake_pos(int shake_pos) {}
+	uint32 get_msecs();
+	void delay_msecs(uint msecs);
+	void *create_thread(ThreadProc *proc, void *param) { return NULL; }
+	bool poll_event(Event *event) { return false; }
+	bool set_sound_proc(void *param, SoundProc *proc, byte sound) {}
+	void quit() { exit(1); }
+	uint32 property(int param, Property *value) { return 0; }
+	static OSystem *create(int gfx_mode, bool full_screen);
+private:
+
+	uint msec_start;
+
+	uint32 get_ticks();
+};
+
+void OSystem_NULL::init_size(uint w, uint h, byte sound) {
+	msec_start = get_ticks();
+}
+
+uint32 OSystem_NULL::get_ticks() {
+	uint a = 0;
+#ifdef WIN32
+	a = GetTickCount();
+#endif
+#ifdef UNIX
+	struct timeval tv;
+	gettimeofday(&tv, NULL);
+	a = tv.tv_sec * 1000 + tv.tv_usec/1000;
+#endif
+
+	return a;
+}
+
+void OSystem_NULL::delay_msecs(uint msecs) {
+#ifdef WIN32
+	Sleep(msecs);
+#endif
+#ifdef UNIX
+	usleep(msecs*1000);
+#endif
+}
+
+uint32 OSystem_NULL::get_msecs() {
+	return get_ticks() - msec_start;
+}
+
+OSystem *OSystem_NULL_create() {
+	return new OSystem_NULL();
+}
+#else /* USE_NULL_DRIVER */
+
+OSystem *OSystem_NULL_create() {
+	return NULL;
+}
+
+#endif
diff --git a/backends/wince/MenuTitle.bmp b/backends/wince/MenuTitle.bmp
new file mode 100644
index 0000000000..34faf3fbb2
--- /dev/null
+++ b/backends/wince/MenuTitle.bmp
diff --git a/backends/wince/PocketSCUMM.rc b/backends/wince/PocketSCUMM.rc
new file mode 100644
index 0000000000..15fc9433ba
--- /dev/null
+++ b/backends/wince/PocketSCUMM.rc
@@ -0,0 +1,209 @@
+//Microsoft Developer Studio generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "newres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "resource.h\0"
+END
+
+2 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "#include ""newres.h""\r\n"
+    "\0"
+END
+
+3 TEXTINCLUDE DISCARDABLE 
+BEGIN
+    "\r\n"
+    "\0"
+END
+
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_GAMESELECT DIALOG DISCARDABLE  0, 0, 128, 134
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION
+CAPTION "Choose a Game"
+FONT 8, "System"
+BEGIN
+    LISTBOX         IDC_LISTAVAILABLE,6,47,113,70,LBS_NOINTEGRALHEIGHT | 
+                    WS_VSCROLL | WS_TABSTOP
+    CONTROL         133,IDC_STATIC,"Static",SS_BITMAP | SS_CENTERIMAGE,0,2,
+                    125,35
+    LTEXT           "",IDC_GAMEDESC,2,117,116,8
+    PUSHBUTTON      "Play",IDC_PLAY,52,125,19,9
+    LTEXT           "",IDC_FILEPATH,5,39,120,8
+    PUSHBUTTON      "Scan",IDC_SCAN,4,125,19,9
+    PUSHBUTTON      "Exit",IDC_EXIT,100,125,19,9
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Menubar
+//
+
+IDM_MENU MENU DISCARDABLE 
+BEGIN
+    POPUP "PocketSCUMM"
+    BEGIN
+        MENUITEM "Load/Save",                   IDC_LOADSAVE
+        MENUITEM "Options",                     IDC_OPTIONS
+        MENUITEM "Exit",                        IDC_EXIT
+        MENUITEM SEPARATOR
+        MENUITEM "Landscape",                   IDC_LANDSCAPE
+        MENUITEM "Skip section",                IDC_SKIP
+        MENUITEM SEPARATOR
+        MENUITEM "Sound",                       IDC_SOUND
+    END
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Data
+//
+
+IDM_MENU SHMENUBAR DISCARDABLE 
+BEGIN
+    IDM_MENU, 1,
+    I_IMAGENONE, IDM_POCKETSCUMM, TBSTATE_ENABLED, 
+    TBSTYLE_DROPDOWN | TBSTYLE_AUTOSIZE, IDS_CAP_POCKETSCUMM, 0, 0,
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// DESIGNINFO
+//
+
+#ifdef APSTUDIO_INVOKED
+GUIDELINES DESIGNINFO DISCARDABLE 
+BEGIN
+    IDD_GAMESELECT, DIALOG
+    BEGIN
+        RIGHTMARGIN, 125
+        HORZGUIDE, 2
+    END
+END
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE DISCARDABLE 
+BEGIN
+    IDS_CAP_POCKETSCUMM     "PocketSCUMM"
+END
+
+#endif    // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+/////////////////////////////////////////////////////////////////////////////
+// French (France) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_FRA)
+#ifdef _WIN32
+LANGUAGE LANG_FRENCH, SUBLANG_FRENCH
+#pragma code_page(1252)
+#endif //_WIN32
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_DIALOG1 DIALOG DISCARDABLE  0, 0, 186, 90
+STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU
+CAPTION "Dialog"
+FONT 8, "System"
+BEGIN
+    DEFPUSHBUTTON   "OK",IDOK,129,7,50,14
+    PUSHBUTTON      "Cancel",IDCANCEL,129,24,50,14
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// DESIGNINFO
+//
+
+#ifdef APSTUDIO_INVOKED
+GUIDELINES DESIGNINFO DISCARDABLE 
+BEGIN
+    IDD_DIALOG1, DIALOG
+    BEGIN
+        LEFTMARGIN, 7
+        RIGHTMARGIN, 179
+        TOPMARGIN, 7
+        BOTTOMMARGIN, 83
+    END
+END
+#endif    // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+IDL_POCKETSCUMM         ICON    DISCARDABLE     "PocketSCUMM.ico"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Bitmap
+//
+
+IDB_MENUTITLE           BITMAP  DISCARDABLE     "MenuTitle.bmp"
+#endif    // French (France) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif    // not APSTUDIO_INVOKED
+
diff --git a/backends/wince/PocketSCUMM.vcc b/backends/wince/PocketSCUMM.vcc
new file mode 100644
index 0000000000..9a25751416
--- /dev/null
+++ b/backends/wince/PocketSCUMM.vcc
@@ -0,0 +1,74 @@
+; CLW file contains information for the MFC ClassWizard
+
+[General Info]
+Version=1
+LastClass=
+LastTemplate=CDialog
+NewFileInclude1=#include "stdafx.h"
+NewFileInclude2=#include "pocketscumm.h"
+LastPage=0
+
+ClassCount=0
+
+ResourceCount=5
+Resource1=IDM_MENU
+Resource2=IDD_DIALOG1
+Resource3=IDD_GAMESELECT
+Resource4=IDD_GAMESELECT (English (U.S.))
+Resource5=IDM_MENU (English (U.S.))
+
+[DLG:IDD_GAMESELECT (English (U.S.))]
+Type=1
+Class=?
+ControlCount=7
+Control1=IDC_LISTAVAILABLE,listbox,1352728833
+Control2=IDC_STATIC,static,1342177806
+Control3=IDC_GAMEDESC,static,1342308352
+Control4=IDC_PLAY,button,1342242816
+Control5=IDC_FILEPATH,static,1342308352
+Control6=IDC_SCAN,button,1342242816
+Control7=IDC_EXIT,button,1342242816
+
+[MNU:IDM_MENU (English (U.S.))]
+Type=1
+Class=?
+Command1=IDC_LOADSAVE
+Command2=IDC_OPTIONS
+Command3=IDC_EXIT
+Command4=IDC_LANDSCAPE
+Command5=IDC_SKIP
+Command6=IDC_SOUND
+CommandCount=6
+
+[DLG:IDD_GAMESELECT]
+Type=1
+Class=?
+ControlCount=7
+Control1=IDC_LISTAVAILABLE,listbox,1352728833
+Control2=IDC_STATIC,static,1342177806
+Control3=IDC_GAMEDESC,static,1342308352
+Control4=IDC_PLAY,button,1342242816
+Control5=IDC_FILEPATH,static,1342308352
+Control6=IDC_SCAN,button,1342242816
+Control7=IDC_EXIT,button,1342242816
+
+[MNU:IDM_MENU]
+Type=1
+Class=?
+Command1=IDC_LOADSAVE
+Command2=IDC_OPTIONS
+Command3=IDC_EXIT
+Command4=IDC_LANDSCAPE
+Command5=IDC_SKIP
+Command6=IDC_SOUND
+CommandCount=6
+
+
+
+[DLG:IDD_DIALOG1]
+Type=1
+Class=?
+ControlCount=2
+Control1=IDOK,button,1342242817
+Control2=IDCANCEL,button,1342242816
+
diff --git a/backends/wince/PocketSCUMM.vcp b/backends/wince/PocketSCUMM.vcp
new file mode 100644
index 0000000000..5809a4d948
--- /dev/null
+++ b/backends/wince/PocketSCUMM.vcp
@@ -0,0 +1,9228 @@
+# Microsoft eMbedded Visual Tools Project File - Name="PocketSCUMM" - Package Owner=<4>
+# Microsoft eMbedded Visual Tools Generated Build File, Format Version 6.02
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (WCE ARM) Application" 0x8501
+# TARGTYPE "Win32 (WCE x86em) Application" 0x7f01
+# TARGTYPE "Win32 (WCE SH3) Application" 0x8101
+# TARGTYPE "Win32 (WCE SH4) Application" 0x8601
+# TARGTYPE "Win32 (WCE MIPS) Application" 0x8201
+
+CFG=PocketSCUMM - Win32 (WCE MIPS) Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "PocketSCUMM.vcn".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "PocketSCUMM.vcn" CFG="PocketSCUMM - Win32 (WCE MIPS) Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "PocketSCUMM - Win32 (WCE MIPS) Release" (based on "Win32 (WCE MIPS) Application")
+!MESSAGE "PocketSCUMM - Win32 (WCE MIPS) Debug" (based on "Win32 (WCE MIPS) Application")
+!MESSAGE "PocketSCUMM - Win32 (WCE SH4) Release" (based on "Win32 (WCE SH4) Application")
+!MESSAGE "PocketSCUMM - Win32 (WCE SH4) Debug" (based on "Win32 (WCE SH4) Application")
+!MESSAGE "PocketSCUMM - Win32 (WCE SH3) Release" (based on "Win32 (WCE SH3) Application")
+!MESSAGE "PocketSCUMM - Win32 (WCE SH3) Debug" (based on "Win32 (WCE SH3) Application")
+!MESSAGE "PocketSCUMM - Win32 (WCE ARM) Release" (based on "Win32 (WCE ARM) Application")
+!MESSAGE "PocketSCUMM - Win32 (WCE ARM) Debug" (based on "Win32 (WCE ARM) Application")
+!MESSAGE "PocketSCUMM - Win32 (WCE x86em) Release" (based on "Win32 (WCE x86em) Application")
+!MESSAGE "PocketSCUMM - Win32 (WCE x86em) Debug" (based on "Win32 (WCE x86em) Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+# PROP ATL_Project 2
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "MIPSRel"
+# PROP BASE Intermediate_Dir "MIPSRel"
+# PROP BASE CPU_ID "{D6519010-710F-11D3-99F2-00105A0DF099}"
+# PROP BASE Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "MIPSRel"
+# PROP Intermediate_Dir "MIPSRel"
+# PROP CPU_ID "{D6519010-710F-11D3-99F2-00105A0DF099}"
+# PROP Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "NDEBUG" /d "$(CePlatform)" /d "MIPS" /d "_MIPS_" /r
+# ADD RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "NDEBUG" /d "$(CePlatform)" /d "MIPS" /d "_MIPS_" /r
+CPP=clmips.exe
+# ADD BASE CPP /nologo /W3 /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "MIPS" /D "_MIPS_" /D UNDER_CE=$(CEVersion) /D "UNICODE" /D "_UNICODE" /D "NDEBUG" /YX /Oxs /M$(CECrtMT) /c
+# ADD CPP /nologo /W3 /I "." /I "missing" /I ".." /I "gapi/inc" /I "SDLAudio/include" /I "mad/include" /D "MIPS" /D "_MIPS_" /D "NDEBUG" /D "WIN32" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /D "SCUMM_NEED_ALIGNMENT" /D "BYPASS_COPY_PROT" /D "USE_ADLIB" /D "__AUTO_MIXER_ADJUST__" /D "FPM_DEFAULT" /D "COMPRESSED_SOUND_FILE" /FR /YX /Oxs /M$(CECrtMT) /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 commctrl.lib coredll.lib aygshell.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /nodefaultlib:"$(CENoDefaultLib)" /subsystem:$(CESubsystem) /MACHINE:MIPS
+# ADD LINK32 commctrl.lib coredll.lib aygshell.lib SDLAudio.lib mad.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /nodefaultlib:"$(CENoDefaultLib)" /libpath:"SDLAudio/lib/MIPS" /libpath:"mad/lib/MIPS" /subsystem:$(CESubsystem) /MACHINE:MIPS
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "MIPSDbg"
+# PROP BASE Intermediate_Dir "MIPSDbg"
+# PROP BASE CPU_ID "{D6519010-710F-11D3-99F2-00105A0DF099}"
+# PROP BASE Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "MIPSDbg"
+# PROP Intermediate_Dir "MIPSDbg"
+# PROP CPU_ID "{D6519010-710F-11D3-99F2-00105A0DF099}"
+# PROP Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "DEBUG" /d "$(CePlatform)" /d "MIPS" /d "_MIPS_" /r
+# ADD RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "DEBUG" /d "$(CePlatform)" /d "MIPS" /d "_MIPS_" /r
+CPP=clmips.exe
+# ADD BASE CPP /nologo /W3 /Zi /Od /D "DEBUG" /D "MIPS" /D "_MIPS_" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /YX /M$(CECrtMTDebug) /c
+# ADD CPP /nologo /W3 /Zi /Od /I "." /I "missing" /I ".." /I "gapi/inc" /D "DEBUG" /D "MIPS" /D "_MIPS_" /D "WIN32" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /D "SCUMM_NEED_ALIGNMENT" /YX /M$(CECrtMTDebug) /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 commctrl.lib coredll.lib aygshell.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /debug /nodefaultlib:"$(CENoDefaultLib)" /subsystem:$(CESubsystem) /MACHINE:MIPS
+# ADD LINK32 commctrl.lib coredll.lib aygshell.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /debug /nodefaultlib:"$(CENoDefaultLib)" /subsystem:$(CESubsystem) /MACHINE:MIPS
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "SH4Rel"
+# PROP BASE Intermediate_Dir "SH4Rel"
+# PROP BASE CPU_ID "{D6519021-710F-11D3-99F2-00105A0DF099}"
+# PROP BASE Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "SH4Rel"
+# PROP Intermediate_Dir "SH4Rel"
+# PROP CPU_ID "{D6519021-710F-11D3-99F2-00105A0DF099}"
+# PROP Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "NDEBUG" /d "UNICODE" /d "_UNICODE" /d "$(CePlatform)" /d "SHx" /d "SH4" /d "_SH4_" /r
+# ADD RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "NDEBUG" /d "UNICODE" /d "_UNICODE" /d "$(CePlatform)" /d "SHx" /d "SH4" /d "_SH4_" /r
+CPP=shcl.exe
+# ADD BASE CPP /nologo /W3 /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "SHx" /D "SH4" /D "_SH4_" /D UNDER_CE=$(CEVersion) /D "UNICODE" /D "_UNICODE" /D "NDEBUG" /YX /Qsh4 /Oxs /M$(CECrtMT) /c
+# ADD CPP /nologo /W3 /I "." /I "missing" /I ".." /I "gapi/inc" /D "SHx" /D "SH4" /D "_SH4_" /D "NDEBUG" /D "WIN32" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /D "SCUMM_NEED_ALIGNMENT" /YX /Qsh4 /Oxs /M$(CECrtMT) /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 commctrl.lib coredll.lib aygshell.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /nodefaultlib:"$(CENoDefaultLib)" /subsystem:$(CESubsystem) /MACHINE:SH4
+# ADD LINK32 commctrl.lib coredll.lib aygshell.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /nodefaultlib:"$(CENoDefaultLib)" /subsystem:$(CESubsystem) /MACHINE:SH4
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "SH4Dbg"
+# PROP BASE Intermediate_Dir "SH4Dbg"
+# PROP BASE CPU_ID "{D6519021-710F-11D3-99F2-00105A0DF099}"
+# PROP BASE Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "SH4Dbg"
+# PROP Intermediate_Dir "SH4Dbg"
+# PROP CPU_ID "{D6519021-710F-11D3-99F2-00105A0DF099}"
+# PROP Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "DEBUG" /d "UNICODE" /d "_UNICODE" /d "$(CePlatform)" /d "SHx" /d "SH4" /d "_SH4_" /r
+# ADD RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "DEBUG" /d "UNICODE" /d "_UNICODE" /d "$(CePlatform)" /d "SHx" /d "SH4" /d "_SH4_" /r
+CPP=shcl.exe
+# ADD BASE CPP /nologo /W3 /Zi /Od /D "DEBUG" /D "SHx" /D "SH4" /D "_SH4_" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /YX /Qsh4 /M$(CECrtMTDebug) /c
+# ADD CPP /nologo /W3 /Zi /Od /I "." /I "missing" /I ".." /I "gapi/inc" /D "DEBUG" /D "SHx" /D "SH4" /D "_SH4_" /D "WIN32" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /D "SCUMM_NEED_ALIGNMENT" /YX /Qsh4 /M$(CECrtMTDebug) /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 commctrl.lib coredll.lib aygshell.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /debug /nodefaultlib:"$(CENoDefaultLib)" /subsystem:$(CESubsystem) /MACHINE:SH4
+# ADD LINK32 commctrl.lib coredll.lib aygshell.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /debug /nodefaultlib:"$(CENoDefaultLib)" /subsystem:$(CESubsystem) /MACHINE:SH4
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "SH3Rel"
+# PROP BASE Intermediate_Dir "SH3Rel"
+# PROP BASE CPU_ID "{D6519020-710F-11D3-99F2-00105A0DF099}"
+# PROP BASE Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "SH3Rel"
+# PROP Intermediate_Dir "SH3Rel"
+# PROP CPU_ID "{D6519020-710F-11D3-99F2-00105A0DF099}"
+# PROP Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "NDEBUG" /d "$(CePlatform)" /d "SHx" /d "SH3" /d "_SH3_" /r
+# ADD RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "NDEBUG" /d "$(CePlatform)" /d "SHx" /d "SH3" /d "_SH3_" /r
+CPP=shcl.exe
+# ADD BASE CPP /nologo /W3 /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "SHx" /D "SH3" /D "_SH3_" /D UNDER_CE=$(CEVersion) /D "UNICODE" /D "_UNICODE" /D "NDEBUG" /YX /Oxs /M$(CECrtMT) /c
+# ADD CPP /nologo /W3 /I "." /I "missing" /I ".." /I "gapi/inc" /I "SDLAudio/include" /I "mad/include" /D "SHx" /D "SH3" /D "_SH3_" /D "NDEBUG" /D "WIN32" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /D "SCUMM_NEED_ALIGNMENT" /D "USE_ADLIB" /D "__AUTO_MIXER_ADJUST__" /D "FPM_DEFAULT" /D "COMPRESSED_SOUND_FILE" /YX /Oxs /M$(CECrtMT) /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 commctrl.lib coredll.lib aygshell.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /nodefaultlib:"$(CENoDefaultLib)" /subsystem:$(CESubsystem) /MACHINE:SH3
+# ADD LINK32 commctrl.lib coredll.lib aygshell.lib SDLAudio.lib mad.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /nodefaultlib:"$(CENoDefaultLib)" /libpath:"SDLAudio/lib/SH3" /libpath:"mad/lib/SH3" /subsystem:$(CESubsystem) /MACHINE:SH3
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "SH3Dbg"
+# PROP BASE Intermediate_Dir "SH3Dbg"
+# PROP BASE CPU_ID "{D6519020-710F-11D3-99F2-00105A0DF099}"
+# PROP BASE Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "SH3Dbg"
+# PROP Intermediate_Dir "SH3Dbg"
+# PROP CPU_ID "{D6519020-710F-11D3-99F2-00105A0DF099}"
+# PROP Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "DEBUG" /d "$(CePlatform)" /d "SHx" /d "SH3" /d "_SH3_" /r
+# ADD RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "DEBUG" /d "$(CePlatform)" /d "SHx" /d "SH3" /d "_SH3_" /r
+CPP=shcl.exe
+# ADD BASE CPP /nologo /W3 /Zi /Od /D "DEBUG" /D "SHx" /D "SH3" /D "_SH3_" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /YX /M$(CECrtMTDebug) /c
+# ADD CPP /nologo /W3 /Zi /Od /I "." /I "missing" /I ".." /I "gapi/inc" /D "DEBUG" /D "SHx" /D "SH3" /D "_SH3_" /D "WIN32" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /D "SCUMM_NEED_ALIGNMENT" /YX /M$(CECrtMTDebug) /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 commctrl.lib coredll.lib aygshell.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /debug /nodefaultlib:"$(CENoDefaultLib)" /subsystem:$(CESubsystem) /MACHINE:SH3
+# ADD LINK32 commctrl.lib coredll.lib aygshell.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /debug /nodefaultlib:"$(CENoDefaultLib)" /subsystem:$(CESubsystem) /MACHINE:SH3
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "ARMRel"
+# PROP BASE Intermediate_Dir "ARMRel"
+# PROP BASE CPU_ID "{D6518FFC-710F-11D3-99F2-00105A0DF099}"
+# PROP BASE Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "ARMRel"
+# PROP Intermediate_Dir "ARMRel"
+# PROP CPU_ID "{D6518FFC-710F-11D3-99F2-00105A0DF099}"
+# PROP Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "NDEBUG" /d "$(CePlatform)" /d "ARM" /d "_ARM_" /r
+# ADD RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "NDEBUG" /d "$(CePlatform)" /d "ARM" /d "_ARM_" /r
+CPP=clarm.exe
+# ADD BASE CPP /nologo /W3 /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "ARM" /D "_ARM_" /D UNDER_CE=$(CEVersion) /D "UNICODE" /D "_UNICODE" /D "NDEBUG" /YX /Oxs /M$(CECrtMT) /c
+# ADD CPP /nologo /W3 /I "." /I "missing" /I ".." /I "../sound" /I "gapi/inc" /I "SDLAudio/include" /I "mad/include" /D "ARM" /D "_ARM_" /D "NDEBUG" /D "WIN32" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /D "SCUMM_NEED_ALIGNMENT" /D "FPM_DEFAULT" /D "COMPRESSED_SOUND_FILE" /FR /YX /Oxs /M$(CECrtMT) /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 commctrl.lib coredll.lib aygshell.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /nodefaultlib:"$(CENoDefaultLib)" /subsystem:$(CESubsystem) /align:"4096" /MACHINE:ARM
+# ADD LINK32 commctrl.lib coredll.lib aygshell.lib SDLAudio.lib mad.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /nodefaultlib:"$(CENoDefaultLib)" /libpath:"SDLAudio/lib/ARM" /libpath:"mad/lib/ARM" /subsystem:$(CESubsystem) /align:"4096" /MACHINE:ARM
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "ARMDbg"
+# PROP BASE Intermediate_Dir "ARMDbg"
+# PROP BASE CPU_ID "{D6518FFC-710F-11D3-99F2-00105A0DF099}"
+# PROP BASE Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "ARMDbg"
+# PROP Intermediate_Dir "ARMDbg"
+# PROP CPU_ID "{D6518FFC-710F-11D3-99F2-00105A0DF099}"
+# PROP Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "DEBUG" /d "$(CePlatform)" /d "ARM" /d "_ARM_" /r
+# ADD RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "DEBUG" /d "$(CePlatform)" /d "ARM" /d "_ARM_" /r
+CPP=clarm.exe
+# ADD BASE CPP /nologo /W3 /Zi /Od /D "DEBUG" /D "ARM" /D "_ARM_" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /YX /M$(CECrtMTDebug) /c
+# ADD CPP /nologo /W3 /Zi /Od /I "." /I "missing" /I ".." /I "../sound" /I "gapi/inc" /I "SDLAudio/include" /I "mad/include" /D "DEBUG" /D "ARM" /D "_ARM_" /D "WIN32" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /D "SCUMM_NEED_ALIGNMENT" /D "FPM_DEFAULT" /D "COMPRESSED_SOUND_FILE" /FR /YX /M$(CECrtMTDebug) /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 commctrl.lib coredll.lib aygshell.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /debug /nodefaultlib:"$(CENoDefaultLib)" /subsystem:$(CESubsystem) /align:"4096" /MACHINE:ARM
+# ADD LINK32 commctrl.lib coredll.lib aygshell.lib SDLAudio.lib mad.lib /nologo /base:"0x00010000" /stack:0x10000,0x1000 /entry:"WinMainCRTStartup" /debug /nodefaultlib:"$(CENoDefaultLib)" /libpath:"SDLAudio/lib/ARM" /libpath:"mad/lib/ARM" /subsystem:$(CESubsystem) /align:"4096" /MACHINE:ARM
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "X86EMRel"
+# PROP BASE Intermediate_Dir "X86EMRel"
+# PROP BASE CPU_ID "{D6518FF4-710F-11D3-99F2-00105A0DF099}"
+# PROP BASE Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "X86EMRel"
+# PROP Intermediate_Dir "X86EMRel"
+# PROP CPU_ID "{D6518FF4-710F-11D3-99F2-00105A0DF099}"
+# PROP Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "NDEBUG" /d "$(CePlatform)" /d "_X86_" /d "x86" /d "i486" /r
+# ADD RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "NDEBUG" /d "$(CePlatform)" /d "_X86_" /d "x86" /d "i486" /r
+CPP=cl.exe
+# ADD BASE CPP /nologo /W3 /D _WIN32_WCE=$(CEVersion) /D "WIN32" /D "STRICT" /D "_WIN32_WCE_EMULATION" /D "INTERNATIONAL" /D "USA" /D "INTLMSG_CODEPAGE" /D "$(CePlatform)" /D "i486" /D UNDER_CE=$(CEVersion) /D "UNICODE" /D "_UNICODE" /D "_X86_" /D "x86" /D "NDEBUG" /YX /Gz /Oxs /c
+# ADD CPP /nologo /W3 /I "." /I "missing" /I ".." /I "gapi/inc" /D "STRICT" /D "_WIN32_WCE_EMULATION" /D "INTERNATIONAL" /D "USA" /D "INTLMSG_CODEPAGE" /D "i486" /D "_X86_" /D "x86" /D "NDEBUG" /D "WIN32" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /D "SCUMM_NEED_ALIGNMENT" /YX /Gz /Oxs /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
+# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /o "NUL" /win32
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 commctrl.lib coredll.lib $(CEx86Corelibc) aygshell.lib /nologo /stack:0x10000,0x1000 /subsystem:windows /nodefaultlib:"OLDNAMES.lib" /nodefaultlib:$(CENoDefaultLib) /windowsce:emulation /MACHINE:IX86
+# ADD LINK32 commctrl.lib coredll.lib $(CEx86Corelibc) aygshell.lib /nologo /stack:0x10000,0x1000 /subsystem:windows /nodefaultlib:"OLDNAMES.lib" /nodefaultlib:$(CENoDefaultLib) /windowsce:emulation /MACHINE:IX86
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "X86EMDbg"
+# PROP BASE Intermediate_Dir "X86EMDbg"
+# PROP BASE CPU_ID "{D6518FF4-710F-11D3-99F2-00105A0DF099}"
+# PROP BASE Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "X86EMDbg"
+# PROP Intermediate_Dir "X86EMDbg"
+# PROP CPU_ID "{D6518FF4-710F-11D3-99F2-00105A0DF099}"
+# PROP Platform_ID "{8A9A2F80-6887-11D3-842E-005004848CBA}"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+RSC=rc.exe
+# ADD BASE RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "DEBUG" /d "$(CePlatform)" /d "_X86_" /d "x86" /d "i486" /r
+# ADD RSC /l 0x409 /d UNDER_CE=$(CEVersion) /d _WIN32_WCE=$(CEVersion) /d "UNICODE" /d "_UNICODE" /d "DEBUG" /d "$(CePlatform)" /d "_X86_" /d "x86" /d "i486" /r
+CPP=cl.exe
+# ADD BASE CPP /nologo /W3 /Zi /Od /D "DEBUG" /D "i486" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "WIN32" /D "STRICT" /D "_WIN32_WCE_EMULATION" /D "INTERNATIONAL" /D "USA" /D "INTLMSG_CODEPAGE" /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /D "_X86_" /D "x86" /YX /Gz /c
+# ADD CPP /nologo /W3 /Zi /Od /I "." /I "missing" /I ".." /I "gapi/inc" /D "DEBUG" /D "i486" /D "STRICT" /D "_WIN32_WCE_EMULATION" /D "INTERNATIONAL" /D "USA" /D "INTLMSG_CODEPAGE" /D "_X86_" /D "x86" /D "WIN32" /D UNDER_CE=$(CEVersion) /D _WIN32_WCE=$(CEVersion) /D "$(CePlatform)" /D "UNICODE" /D "_UNICODE" /D "SCUMM_NEED_ALIGNMENT" /YX /Gz /c
+MTL=midl.exe
+# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
+# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /o "NUL" /win32
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 commctrl.lib coredll.lib $(CEx86Corelibc) aygshell.lib /nologo /stack:0x10000,0x1000 /subsystem:windows /debug /nodefaultlib:"OLDNAMES.lib" /nodefaultlib:$(CENoDefaultLib) /windowsce:emulation /MACHINE:IX86
+# ADD LINK32 commctrl.lib coredll.lib $(CEx86Corelibc) aygshell.lib /nologo /stack:0x10000,0x1000 /subsystem:windows /debug /nodefaultlib:"OLDNAMES.lib" /nodefaultlib:$(CENoDefaultLib) /windowsce:emulation /MACHINE:IX86
+
+!ENDIF 
+
+# Begin Target
+
+# Name "PocketSCUMM - Win32 (WCE MIPS) Release"
+# Name "PocketSCUMM - Win32 (WCE MIPS) Debug"
+# Name "PocketSCUMM - Win32 (WCE SH4) Release"
+# Name "PocketSCUMM - Win32 (WCE SH4) Debug"
+# Name "PocketSCUMM - Win32 (WCE SH3) Release"
+# Name "PocketSCUMM - Win32 (WCE SH3) Debug"
+# Name "PocketSCUMM - Win32 (WCE ARM) Release"
+# Name "PocketSCUMM - Win32 (WCE ARM) Debug"
+# Name "PocketSCUMM - Win32 (WCE x86em) Release"
+# Name "PocketSCUMM - Win32 (WCE x86em) Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Group "sound"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\sound\fmopl.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_FMOPL=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\fmopl.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_FMOPL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_FMOPL=\
+	"..\sound\fmopl.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_FMOPL=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_FMOPL=\
+	"..\sound\fmopl.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_FMOPL=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_FMOPL=\
+	"..\sound\fmopl.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_FMOPL=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_FMOPL=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\fmopl.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_FMOPL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_FMOPL=\
+	"..\sound\fmopl.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_FMOPL=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_FMOPL=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\fmopl.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_FMOPL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_FMOPL=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\fmopl.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_FMOPL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_FMOPL=\
+	"..\sound\fmopl.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_FMOPL=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_FMOPL=\
+	"..\sound\fmopl.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\sound\imuse.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_IMUSE=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\morphos\morphos.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\fmopl.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_IMUSE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_IMUSE=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_IMUSE=\
+	"..\sound.h"\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_IMUSE=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_IMUSE=\
+	"..\sound.h"\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_IMUSE=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_IMUSE=\
+	"..\sound.h"\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_IMUSE=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\morphos\morphos.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\fmopl.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_IMUSE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_IMUSE=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_IMUSE=\
+	"..\sound.h"\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_IMUSE=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\morphos\morphos.h"\
+	"..\saveload.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\fmopl.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_IMUSE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_IMUSE=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\morphos\morphos.h"\
+	"..\saveload.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\fmopl.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_IMUSE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_IMUSE=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_IMUSE=\
+	"..\sound.h"\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_IMUSE=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\sys\time.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_IMUSE=\
+	"..\sound.h"\
+	"..\sound\gmidi.h"\
+	"..\sound\QuickTimeMusic.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\sound\mididrv.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_MIDID=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\fmopl.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_MIDID=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_MIDID=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\sys\time.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_MIDID=\
+	"..\sound.h"\
+	"..\sound\gmidi.h"\
+	"..\sound\QuickTimeMusic.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_MIDID=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\sys\time.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_MIDID=\
+	"..\sound.h"\
+	"..\sound\gmidi.h"\
+	"..\sound\QuickTimeMusic.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_MIDID=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\sys\time.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_MIDID=\
+	"..\sound.h"\
+	"..\sound\gmidi.h"\
+	"..\sound\QuickTimeMusic.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_MIDID=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\fmopl.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_MIDID=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_MIDID=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\sys\time.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_MIDID=\
+	"..\sound.h"\
+	"..\sound\gmidi.h"\
+	"..\sound\QuickTimeMusic.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_MIDID=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\fmopl.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_MIDID=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_MIDID=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\fmopl.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_MIDID=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_MIDID=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\sys\time.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_MIDID=\
+	"..\sound.h"\
+	"..\sound\gmidi.h"\
+	"..\sound\QuickTimeMusic.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_MIDID=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\sys\time.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_MIDID=\
+	"..\sound.h"\
+	"..\sound\gmidi.h"\
+	"..\sound\QuickTimeMusic.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\sound\mididrv.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\sound\mixer.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_MIXER=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_MIXER=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_MIXER=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_MIXER=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_MIXER=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_MIXER=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_MIXER=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_MIXER=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_MIXER=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_MIXER=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_MIXER=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_MIXER=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_MIXER=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_MIXER=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\sound\mixer.h
+# End Source File
+# End Group
+# Begin Group "v3"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\v3\resource_v3.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_RESOU=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_RESOU=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_RESOU=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOU=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_RESOU=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOU=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_RESOU=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOU=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_RESOU=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_RESOU=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_RESOU=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOU=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_RESOU=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\myresource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_RESOU=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_RESOU=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\myresource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_RESOU=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_RESOU=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOU=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_RESOU=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOU=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "v4"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\v4\resource_v4.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_RESOUR=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_RESOUR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_RESOUR=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOUR=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_RESOUR=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOUR=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_RESOUR=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOUR=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_RESOUR=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_RESOUR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_RESOUR=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOUR=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_RESOUR=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_RESOUR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_RESOUR=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_RESOUR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_RESOUR=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOUR=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_RESOUR=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOUR=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "simon"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\simon\midi.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_MIDI_=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_MIDI_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_MIDI_=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_MIDI_=\
+	"..\simon\gmidi.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_MIDI_=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_MIDI_=\
+	"..\simon\gmidi.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_MIDI_=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_MIDI_=\
+	"..\simon\gmidi.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_MIDI_=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_MIDI_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_MIDI_=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_MIDI_=\
+	"..\simon\gmidi.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_MIDI_=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_MIDI_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_MIDI_=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_MIDI_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_MIDI_=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_MIDI_=\
+	"..\simon\gmidi.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_MIDI_=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_MIDI_=\
+	"..\simon\gmidi.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\simon\simon.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SIMON=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMON=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SIMON=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SIMON=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SIMON=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SIMON=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMON=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SIMON=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SIMON=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMON=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SIMON=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMON=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SIMON=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SIMON=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\simon\simon.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\simon\simondebug.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SIMOND=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMOND=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SIMOND=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMOND=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SIMOND=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMOND=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SIMOND=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMOND=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SIMOND=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMOND=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SIMOND=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMOND=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SIMOND=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMOND=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SIMOND=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMOND=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SIMOND=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMOND=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SIMOND=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMOND=\
+	"..\macos.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\simon\simonitems.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SIMONI=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONI=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SIMONI=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONI=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SIMONI=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONI=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SIMONI=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONI=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SIMONI=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONI=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SIMONI=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONI=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SIMONI=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONI=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SIMONI=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONI=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SIMONI=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONI=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SIMONI=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONI=\
+	"..\macos.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\simon\simonres.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SIMONR=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SIMONR=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SIMONR=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SIMONR=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SIMONR=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SIMONR=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SIMONR=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SIMONR=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SIMONR=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SIMONR=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONR=\
+	"..\macos.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\simon\simonsys.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SIMONS=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONS=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SIMONS=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SIMONS=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SIMONS=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SIMONS=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONS=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SIMONS=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SIMONS=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONS=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SIMONS=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONS=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SIMONS=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SIMONS=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\simon\simonverb.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SIMONV=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONV=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SIMONV=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONV=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SIMONV=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONV=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SIMONV=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONV=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SIMONV=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONV=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SIMONV=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONV=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SIMONV=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONV=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SIMONV=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONV=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SIMONV=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONV=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SIMONV=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONV=\
+	"..\macos.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\simon\simonvga.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SIMONVG=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONVG=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SIMONVG=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONVG=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SIMONVG=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONVG=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SIMONVG=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONVG=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SIMONVG=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONVG=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SIMONVG=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONVG=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SIMONVG=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONVG=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SIMONVG=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SIMONVG=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SIMONVG=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONVG=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SIMONVG=\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SIMONVG=\
+	"..\macos.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "gui"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\gui\dialog.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_DIALO=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_DIALO=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_DIALO=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_DIALO=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_DIALO=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_DIALO=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_DIALO=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_DIALO=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_DIALO=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_DIALO=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_DIALO=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_DIALO=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_DIALO=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_DIALO=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_DIALO=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_DIALO=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_DIALO=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_DIALO=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_DIALO=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_DIALO=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\gui\dialog.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\gui\ListWidget.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_LISTW=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_LISTW=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_LISTW=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_LISTW=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_LISTW=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_LISTW=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_LISTW=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_LISTW=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_LISTW=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_LISTW=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_LISTW=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_LISTW=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_LISTW=\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_LISTW=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_LISTW=\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_LISTW=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_LISTW=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_LISTW=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_LISTW=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_LISTW=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\gui\ListWidget.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\gui\ScrollBarWidget.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SCROL=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCROL=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SCROL=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCROL=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SCROL=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCROL=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SCROL=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCROL=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SCROL=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCROL=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SCROL=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCROL=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SCROL=\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCROL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SCROL=\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCROL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SCROL=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCROL=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SCROL=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ScrollBarWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCROL=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\gui\ScrollBarWidget.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\gui\widget.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_WIDGE=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_WIDGE=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_WIDGE=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_WIDGE=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_WIDGE=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_WIDGE=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_WIDGE=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_WIDGE=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_WIDGE=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_WIDGE=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_WIDGE=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_WIDGE=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_WIDGE=\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_WIDGE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_WIDGE=\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_WIDGE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_WIDGE=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_WIDGE=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_WIDGE=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_WIDGE=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\gui\widget.h
+# End Source File
+# End Group
+# Begin Source File
+
+SOURCE=..\actor.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_ACTOR=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_ACTOR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_ACTOR=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_ACTOR=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_ACTOR=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_ACTOR=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_ACTOR=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_ACTOR=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_ACTOR=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_ACTOR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_ACTOR=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_ACTOR=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_ACTOR=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\costume.h"\
+	"..\gfx.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_ACTOR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_ACTOR=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\costume.h"\
+	"..\gfx.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_ACTOR=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_ACTOR=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_ACTOR=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_ACTOR=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_ACTOR=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\akos.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_AKOS_=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_AKOS_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_AKOS_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_AKOS_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_AKOS_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_AKOS_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_AKOS_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_AKOS_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_AKOS_=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_AKOS_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_AKOS_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_AKOS_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_AKOS_=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_AKOS_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_AKOS_=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_AKOS_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_AKOS_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_AKOS_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_AKOS_=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_AKOS_=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\boxes.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_BOXES=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_BOXES=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_BOXES=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_BOXES=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_BOXES=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_BOXES=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_BOXES=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_BOXES=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_BOXES=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_BOXES=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_BOXES=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_BOXES=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_BOXES=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_BOXES=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_BOXES=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_BOXES=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_BOXES=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_BOXES=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_BOXES=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_BOXES=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\bundle.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_BUNDL=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_BUNDL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_BUNDL=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_BUNDL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_BUNDL=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_BUNDL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_BUNDL=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_BUNDL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_BUNDL=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_BUNDL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_BUNDL=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_BUNDL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_BUNDL=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_BUNDL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_BUNDL=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_BUNDL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_BUNDL=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_BUNDL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_BUNDL=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_BUNDL=\
+	"..\macos.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE="..\config-file.cpp"
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_CONFI=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_CONFI=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_CONFI=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_CONFI=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_CONFI=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_CONFI=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_CONFI=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_CONFI=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_CONFI=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_CONFI=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_CONFI=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_CONFI=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_CONFI=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_CONFI=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\costume.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_COSTU=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_COSTU=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_COSTU=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_COSTU=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_COSTU=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_COSTU=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_COSTU=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_COSTU=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_COSTU=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_COSTU=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_COSTU=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_COSTU=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_COSTU=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\costume.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_COSTU=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_COSTU=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\costume.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_COSTU=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_COSTU=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_COSTU=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_COSTU=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_COSTU=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\gameDetector.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_GAMED=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_GAMED=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_GAMED=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GAMED=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_GAMED=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GAMED=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_GAMED=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GAMED=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_GAMED=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_GAMED=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_GAMED=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GAMED=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_GAMED=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_GAMED=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_GAMED=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_GAMED=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_GAMED=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GAMED=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_GAMED=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GAMED=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\gfx.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_GFX_C=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_GFX_C=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_GFX_C=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GFX_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_GFX_C=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GFX_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_GFX_C=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GFX_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_GFX_C=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_GFX_C=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_GFX_C=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GFX_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_GFX_C=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\newgui.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_GFX_C=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_GFX_C=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\newgui.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_GFX_C=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_GFX_C=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GFX_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_GFX_C=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GFX_C=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\gui.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_GUI_C=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gapi_keys.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\guimaps.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_GUI_C=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_GUI_C=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GUI_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_GUI_C=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GUI_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_GUI_C=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GUI_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_GUI_C=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gapi_keys.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\guimaps.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_GUI_C=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_GUI_C=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GUI_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_GUI_C=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gapi_keys.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\guimaps.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_GUI_C=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_GUI_C=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gapi_keys.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\guimaps.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_GUI_C=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_GUI_C=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GUI_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_GUI_C=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gapi_keys.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\guimaps.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_GUI_C=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\insane.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_INSAN=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_INSAN=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_INSAN=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_INSAN=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_INSAN=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_INSAN=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_INSAN=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_INSAN=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_INSAN=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_INSAN=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_INSAN=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_INSAN=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_INSAN=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_INSAN=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_INSAN=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_INSAN=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_INSAN=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_INSAN=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_INSAN=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_INSAN=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\newgui.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_NEWGU=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\guimaps.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_NEWGU=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_NEWGU=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\guimaps.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_NEWGU=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_NEWGU=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\guimaps.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_NEWGU=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_NEWGU=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\guimaps.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_NEWGU=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_NEWGU=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\guimaps.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_NEWGU=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_NEWGU=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\guimaps.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_NEWGU=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_NEWGU=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\guimaps.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_NEWGU=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_NEWGU=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\ListWidget.h"\
+	"..\gui\widget.h"\
+	"..\guimaps.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_NEWGU=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_NEWGU=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\guimaps.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_NEWGU=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_NEWGU=\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui\dialog.h"\
+	"..\gui\widget.h"\
+	"..\guimaps.h"\
+	"..\newgui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_NEWGU=\
+	"..\gui\util.h"\
+	"..\macos.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\object.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_OBJEC=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_OBJEC=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_OBJEC=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_OBJEC=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_OBJEC=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_OBJEC=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_OBJEC=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_OBJEC=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_OBJEC=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_OBJEC=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_OBJEC=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_OBJEC=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_OBJEC=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\object.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_OBJEC=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_OBJEC=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\object.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_OBJEC=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_OBJEC=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_OBJEC=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_OBJEC=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_OBJEC=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\resource.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_RESOURC=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_RESOURC=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_RESOURC=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOURC=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_RESOURC=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOURC=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_RESOURC=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOURC=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_RESOURC=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_RESOURC=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_RESOURC=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOURC=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_RESOURC=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_RESOURC=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_RESOURC=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_RESOURC=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_RESOURC=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOURC=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_RESOURC=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_RESOURC=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\saveload.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SAVEL=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SAVEL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SAVEL=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SAVEL=\
+	"..\sound.h"\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SAVEL=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SAVEL=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SAVEL=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SAVEL=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SAVEL=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SAVEL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SAVEL=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SAVEL=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SAVEL=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\resource.h"\
+	"..\saveload.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SAVEL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SAVEL=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\resource.h"\
+	"..\saveload.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SAVEL=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SAVEL=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SAVEL=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SAVEL=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SAVEL=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\scaler.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SCALE=\
+	"..\scaler.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCALE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SCALE=\
+	"..\scaler.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCALE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SCALE=\
+	"..\scaler.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCALE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SCALE=\
+	"..\scaler.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCALE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SCALE=\
+	"..\scaler.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCALE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SCALE=\
+	"..\scaler.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCALE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SCALE=\
+	"..\scaler.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCALE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SCALE=\
+	"..\scaler.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCALE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SCALE=\
+	"..\scaler.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCALE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SCALE=\
+	"..\scaler.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCALE=\
+	"..\macos.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\script.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SCRIP=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCRIP=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SCRIP=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIP=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SCRIP=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIP=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SCRIP=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIP=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SCRIP=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCRIP=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SCRIP=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIP=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SCRIP=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCRIP=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SCRIP=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCRIP=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SCRIP=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIP=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SCRIP=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIP=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\script_v1.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SCRIPT=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCRIPT=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SCRIPT=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIPT=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SCRIPT=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIPT=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SCRIPT=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIPT=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SCRIPT=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCRIPT=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SCRIPT=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIPT=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SCRIPT=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCRIPT=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SCRIPT=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCRIPT=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SCRIPT=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIPT=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SCRIPT=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIPT=\
+	"..\cdmusic.h"\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\script_v2.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SCRIPT_=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCRIPT_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SCRIPT_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIPT_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SCRIPT_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIPT_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SCRIPT_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIPT_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SCRIPT_=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCRIPT_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SCRIPT_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIPT_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SCRIPT_=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCRIPT_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SCRIPT_=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCRIPT_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SCRIPT_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIPT_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SCRIPT_=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCRIPT_=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\scummvm.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SCUMM=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCUMM=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SCUMM=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCUMM=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SCUMM=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCUMM=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SCUMM=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCUMM=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SCUMM=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCUMM=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SCUMM=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCUMM=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SCUMM=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\debug.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\newgui.h"\
+	"..\object.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCUMM=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SCUMM=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\debug.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\newgui.h"\
+	"..\object.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SCUMM=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SCUMM=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCUMM=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SCUMM=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gameDetector.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SCUMM=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\sound.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SOUND=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SOUND=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SOUND=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SOUND=\
+	"..\sound.h"\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SOUND=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SOUND=\
+	"..\sound.h"\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SOUND=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SOUND=\
+	"..\sound.h"\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SOUND=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SOUND=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SOUND=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SOUND=\
+	"..\sound.h"\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SOUND=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SOUND=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SOUND=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\imuse.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SOUND=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SOUND=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SOUND=\
+	"..\sound.h"\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SOUND=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SOUND=\
+	"..\cdmusic.h"\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\stdafx.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_STDAF=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_STDAF=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_STDAF=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_STDAF=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_STDAF=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_STDAF=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_STDAF=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_STDAF=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_STDAF=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_STDAF=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_STDAF=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_STDAF=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_STDAF=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_STDAF=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_STDAF=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\string.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_STRIN=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_STRIN=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_STRIN=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_STRIN=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_STRIN=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_STRIN=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_STRIN=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_STRIN=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_STRIN=\
+	"..\actor.h"\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_STRIN=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_STRIN=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_STRIN=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_STRIN=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_STRIN=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_STRIN=\
+	"..\actor.h"\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_STRIN=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_STRIN=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_STRIN=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_STRIN=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_STRIN=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\sys.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SYS_C=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SYS_C=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SYS_C=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SYS_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SYS_C=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SYS_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SYS_C=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SYS_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SYS_C=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SYS_C=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SYS_C=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SYS_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SYS_C=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SYS_C=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SYS_C=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_SYS_C=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SYS_C=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SYS_C=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SYS_C=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_SYS_C=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\util.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_UTIL_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_UTIL_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_UTIL_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_UTIL_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_UTIL_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_UTIL_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_UTIL_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_UTIL_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_UTIL_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_UTIL_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\vars.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_VARS_=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_VARS_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_VARS_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_VARS_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_VARS_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_VARS_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_VARS_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_VARS_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_VARS_=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_VARS_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_VARS_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_VARS_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_VARS_=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_VARS_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_VARS_=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_VARS_=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_VARS_=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_VARS_=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_VARS_=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_VARS_=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=..\verbs.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_VERBS=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_VERBS=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_VERBS=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_VERBS=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_VERBS=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_VERBS=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_VERBS=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_VERBS=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_VERBS=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_VERBS=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_VERBS=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_VERBS=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_VERBS=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\object.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_VERBS=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_VERBS=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\gfx.h"\
+	"..\object.h"\
+	"..\resource.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_VERBS=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_VERBS=\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_VERBS=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_VERBS=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_VERBS=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\akos.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\boxes.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\bundle.h
+# End Source File
+# Begin Source File
+
+SOURCE="..\config-file.h"
+# End Source File
+# Begin Source File
+
+SOURCE=..\sound\fmopl.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\gapi_keys.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\gui.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\guimaps.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\newgui.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\scaler.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\scumm.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\scummsys.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\stdafx.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\util.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# Begin Source File
+
+SOURCE=.\MenuTitle.bmp
+# End Source File
+# Begin Source File
+
+SOURCE=.\pocketscumm.ico
+# End Source File
+# End Group
+# Begin Group "Port Source Files"
+
+# PROP Default_Filter "cpp"
+# Begin Source File
+
+SOURCE=.\bitmaps.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_BITMA=\
+	".\screen.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_BITMA=\
+	".\screen.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_BITMA=\
+	".\screen.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_BITMA=\
+	".\screen.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_BITMA=\
+	".\screen.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_BITMA=\
+	".\screen.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_BITMA=\
+	".\screen.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_BITMA=\
+	".\screen.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_BITMA=\
+	".\screen.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_BITMA=\
+	".\screen.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\findgame.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_FINDG=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_FINDG=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_FINDG=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_FINDG=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_FINDG=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_FINDG=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_FINDG=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_FINDG=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_FINDG=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_FINDG=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_FINDG=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_FINDG=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_FINDG=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_FINDG=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_FINDG=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\gfx.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	
+NODEP_CPP_FINDG=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_FINDG=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_FINDG=\
+	".\SDL.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_FINDG=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\gapi_keys.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_GAPI_=\
+	"..\gapi_keys.h"\
+	"..\stdafx.h"\
+	".\gapi\inc\gx.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	
+NODEP_CPP_GAPI_=\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_GAPI_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	
+NODEP_CPP_GAPI_=\
+	".\gapi\inc\gx.h"\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_GAPI_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	
+NODEP_CPP_GAPI_=\
+	".\gapi\inc\gx.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_GAPI_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	
+NODEP_CPP_GAPI_=\
+	".\gapi\inc\gx.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_GAPI_=\
+	"..\gapi_keys.h"\
+	"..\stdafx.h"\
+	".\gapi\inc\gx.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	
+NODEP_CPP_GAPI_=\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_GAPI_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	
+NODEP_CPP_GAPI_=\
+	".\gapi\inc\gx.h"\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_GAPI_=\
+	"..\gapi_keys.h"\
+	"..\stdafx.h"\
+	".\gapi\inc\gx.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	{$(INCLUDE)}"Aygshell.h"\
+	{$(INCLUDE)}"sipapi.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_GAPI_=\
+	"..\gapi_keys.h"\
+	"..\stdafx.h"\
+	".\gapi\inc\gx.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	{$(INCLUDE)}"Aygshell.h"\
+	{$(INCLUDE)}"sipapi.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_GAPI_=\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	
+NODEP_CPP_GAPI_=\
+	".\gapi\inc\gx.h"\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_GAPI_=\
+	"..\stdafx.h"\
+	".\gapi\inc\gx.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	
+NODEP_CPP_GAPI_=\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\missing.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_MISSI=\
+	".\missing\dirent.h"\
+	".\missing\sys\time.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_MISSI=\
+	".\missing\dirent.h"\
+	".\missing\sys\time.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_MISSI=\
+	".\missing\dirent.h"\
+	".\missing\sys\time.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_MISSI=\
+	".\missing\dirent.h"\
+	".\missing\sys\time.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_MISSI=\
+	".\missing\dirent.h"\
+	".\missing\sys\time.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_MISSI=\
+	".\missing\dirent.h"\
+	".\missing\sys\time.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_MISSI=\
+	".\missing\dirent.h"\
+	".\missing\sys\time.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_MISSI=\
+	".\missing\dirent.h"\
+	".\missing\sys\time.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_MISSI=\
+	".\missing\dirent.h"\
+	".\missing\sys\time.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_MISSI=\
+	".\missing\dirent.h"\
+	".\missing\sys\time.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\pocketpc.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_POCKE=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gameDetector.h"\
+	"..\gapi_keys.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\smush.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\gapi\inc\gx.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	".\SDLAudio\include\begin_code.h"\
+	".\SDLAudio\include\close_code.h"\
+	".\SDLAudio\include\SDL.h"\
+	".\SDLAudio\include\SDL_active.h"\
+	".\SDLAudio\include\SDL_audio.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	".\SDLAudio\include\SDL_cdrom.h"\
+	".\SDLAudio\include\SDL_error.h"\
+	".\SDLAudio\include\SDL_events.h"\
+	".\SDLAudio\include\SDL_getenv.h"\
+	".\SDLAudio\include\SDL_joystick.h"\
+	".\SDLAudio\include\SDL_keyboard.h"\
+	".\SDLAudio\include\SDL_keysym.h"\
+	".\SDLAudio\include\SDL_main.h"\
+	".\SDLAudio\include\SDL_mouse.h"\
+	".\SDLAudio\include\SDL_mutex.h"\
+	".\SDLAudio\include\SDL_quit.h"\
+	".\SDLAudio\include\SDL_rwops.h"\
+	".\SDLAudio\include\SDL_thread.h"\
+	".\SDLAudio\include\SDL_timer.h"\
+	".\SDLAudio\include\SDL_types.h"\
+	".\SDLAudio\include\SDL_version.h"\
+	".\SDLAudio\include\SDL_video.h"\
+	
+NODEP_CPP_POCKE=\
+	"..\macos.h"\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_POCKE=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_POCKE=\
+	"..\sound.h"\
+	".\ipapi.h"\
+	".\screen.h"\
+	".\SDL.h"\
+	".\ygshell.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_POCKE=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_POCKE=\
+	".\screen.h"\
+	".\SDL.h"\
+	".\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_POCKE=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_POCKE=\
+	".\screen.h"\
+	".\SDL.h"\
+	".\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_POCKE=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\config-file.h"\
+	"..\gameDetector.h"\
+	"..\gapi_keys.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\smush.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\gapi\inc\gx.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	".\SDLAudio\include\begin_code.h"\
+	".\SDLAudio\include\close_code.h"\
+	".\SDLAudio\include\SDL.h"\
+	".\SDLAudio\include\SDL_active.h"\
+	".\SDLAudio\include\SDL_audio.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	".\SDLAudio\include\SDL_cdrom.h"\
+	".\SDLAudio\include\SDL_error.h"\
+	".\SDLAudio\include\SDL_events.h"\
+	".\SDLAudio\include\SDL_getenv.h"\
+	".\SDLAudio\include\SDL_joystick.h"\
+	".\SDLAudio\include\SDL_keyboard.h"\
+	".\SDLAudio\include\SDL_keysym.h"\
+	".\SDLAudio\include\SDL_main.h"\
+	".\SDLAudio\include\SDL_mouse.h"\
+	".\SDLAudio\include\SDL_mutex.h"\
+	".\SDLAudio\include\SDL_quit.h"\
+	".\SDLAudio\include\SDL_rwops.h"\
+	".\SDLAudio\include\SDL_thread.h"\
+	".\SDLAudio\include\SDL_timer.h"\
+	".\SDLAudio\include\SDL_types.h"\
+	".\SDLAudio\include\SDL_version.h"\
+	".\SDLAudio\include\SDL_video.h"\
+	
+NODEP_CPP_POCKE=\
+	"..\macos.h"\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_POCKE=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_POCKE=\
+	".\screen.h"\
+	".\SDL.h"\
+	".\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_POCKE=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\debug.h"\
+	"..\gameDetector.h"\
+	"..\gapi_keys.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\gapi\inc\gx.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	".\SDLAudio\include\begin_code.h"\
+	".\SDLAudio\include\close_code.h"\
+	".\SDLAudio\include\SDL.h"\
+	".\SDLAudio\include\SDL_active.h"\
+	".\SDLAudio\include\SDL_audio.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	".\SDLAudio\include\SDL_cdrom.h"\
+	".\SDLAudio\include\SDL_error.h"\
+	".\SDLAudio\include\SDL_events.h"\
+	".\SDLAudio\include\SDL_getenv.h"\
+	".\SDLAudio\include\SDL_joystick.h"\
+	".\SDLAudio\include\SDL_keyboard.h"\
+	".\SDLAudio\include\SDL_keysym.h"\
+	".\SDLAudio\include\SDL_main.h"\
+	".\SDLAudio\include\SDL_mouse.h"\
+	".\SDLAudio\include\SDL_mutex.h"\
+	".\SDLAudio\include\SDL_quit.h"\
+	".\SDLAudio\include\SDL_rwops.h"\
+	".\SDLAudio\include\SDL_thread.h"\
+	".\SDLAudio\include\SDL_timer.h"\
+	".\SDLAudio\include\SDL_types.h"\
+	".\SDLAudio\include\SDL_version.h"\
+	".\SDLAudio\include\SDL_video.h"\
+	{$(INCLUDE)}"Aygshell.h"\
+	{$(INCLUDE)}"sipapi.h"\
+	
+NODEP_CPP_POCKE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_POCKE=\
+	"..\boxes.h"\
+	"..\bundle.h"\
+	"..\config-file.h"\
+	"..\debug.h"\
+	"..\gameDetector.h"\
+	"..\gapi_keys.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\simon\simon.h"\
+	"..\sound\mididrv.h"\
+	"..\sound\mixer.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\gapi\inc\gx.h"\
+	".\mad\include\mad.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	".\SDLAudio\include\begin_code.h"\
+	".\SDLAudio\include\close_code.h"\
+	".\SDLAudio\include\SDL.h"\
+	".\SDLAudio\include\SDL_active.h"\
+	".\SDLAudio\include\SDL_audio.h"\
+	".\SDLAudio\include\SDL_byteorder.h"\
+	".\SDLAudio\include\SDL_cdrom.h"\
+	".\SDLAudio\include\SDL_error.h"\
+	".\SDLAudio\include\SDL_events.h"\
+	".\SDLAudio\include\SDL_getenv.h"\
+	".\SDLAudio\include\SDL_joystick.h"\
+	".\SDLAudio\include\SDL_keyboard.h"\
+	".\SDLAudio\include\SDL_keysym.h"\
+	".\SDLAudio\include\SDL_main.h"\
+	".\SDLAudio\include\SDL_mouse.h"\
+	".\SDLAudio\include\SDL_mutex.h"\
+	".\SDLAudio\include\SDL_quit.h"\
+	".\SDLAudio\include\SDL_rwops.h"\
+	".\SDLAudio\include\SDL_thread.h"\
+	".\SDLAudio\include\SDL_timer.h"\
+	".\SDLAudio\include\SDL_types.h"\
+	".\SDLAudio\include\SDL_version.h"\
+	".\SDLAudio\include\SDL_video.h"\
+	{$(INCLUDE)}"Aygshell.h"\
+	{$(INCLUDE)}"sipapi.h"\
+	
+NODEP_CPP_POCKE=\
+	"..\macos.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_POCKE=\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\stdafx.h"\
+	".\missing\unistd.h"\
+	
+NODEP_CPP_POCKE=\
+	".\screen.h"\
+	".\SDL.h"\
+	".\sound.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_POCKE=\
+	"..\akos.h"\
+	"..\boxes.h"\
+	"..\gfx.h"\
+	"..\gui.h"\
+	"..\scumm.h"\
+	"..\scummsys.h"\
+	"..\smush.h"\
+	"..\stdafx.h"\
+	"..\system.h"\
+	".\gapi\inc\gx.h"\
+	".\missing\unistd.h"\
+	".\screen.h"\
+	
+NODEP_CPP_POCKE=\
+	"..\gmidi.h"\
+	"..\sound.h"\
+	".\ipapi.h"\
+	".\SDL.h"\
+	".\SDL_audio.h"\
+	".\SDL_thread.h"\
+	".\SDL_timer.h"\
+	".\ygshell.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\PocketSCUMM.rc
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\screen.cpp
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+DEP_CPP_SCREE=\
+	".\gapi\inc\gx.h"\
+	".\screen.h"\
+	
+NODEP_CPP_SCREE=\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+DEP_CPP_SCREE=\
+	".\screen.h"\
+	
+NODEP_CPP_SCREE=\
+	".\gapi\inc\gx.h"\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+DEP_CPP_SCREE=\
+	".\screen.h"\
+	
+NODEP_CPP_SCREE=\
+	".\gapi\inc\gx.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+DEP_CPP_SCREE=\
+	".\screen.h"\
+	
+NODEP_CPP_SCREE=\
+	".\gapi\inc\gx.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+DEP_CPP_SCREE=\
+	".\gapi\inc\gx.h"\
+	".\screen.h"\
+	
+NODEP_CPP_SCREE=\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+DEP_CPP_SCREE=\
+	".\screen.h"\
+	
+NODEP_CPP_SCREE=\
+	".\gapi\inc\gx.h"\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+DEP_CPP_SCREE=\
+	".\gapi\inc\gx.h"\
+	".\screen.h"\
+	{$(INCLUDE)}"Aygshell.h"\
+	{$(INCLUDE)}"sipapi.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+DEP_CPP_SCREE=\
+	".\gapi\inc\gx.h"\
+	".\screen.h"\
+	{$(INCLUDE)}"Aygshell.h"\
+	{$(INCLUDE)}"sipapi.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+DEP_CPP_SCREE=\
+	".\screen.h"\
+	
+NODEP_CPP_SCREE=\
+	".\gapi\inc\gx.h"\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+DEP_CPP_SCREE=\
+	".\gapi\inc\gx.h"\
+	".\screen.h"\
+	
+NODEP_CPP_SCREE=\
+	".\ipapi.h"\
+	".\ygshell.h"\
+	
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\gapi\ARM\gx.lib
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\gapi\emu\gx.lib
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\gapi\MIPS\gx.lib
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ENDIF 
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\gapi\SH\gx.lib
+
+!IF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE MIPS) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Release"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH4) Debug"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Release"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE SH3) Debug"
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE ARM) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Release"
+
+# PROP Exclude_From_Build 1
+
+!ELSEIF  "$(CFG)" == "PocketSCUMM - Win32 (WCE x86em) Debug"
+
+# PROP Exclude_From_Build 1
+
+!ENDIF 
+
+# End Source File
+# End Group
+# Begin Group "Port Header Files"
+
+# PROP Default_Filter "h"
+# Begin Source File
+
+SOURCE=.\missing\assert.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\conio.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\dir.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\direct.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\dirent.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\errno.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\fcntl.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\io.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\newres.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\resource.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\screen.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\signal.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\sys\stat.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\sys\time.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\time.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\sys\types.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\missing\unistd.h
+# End Source File
+# End Group
+# End Target
+# End Project
diff --git a/backends/wince/PocketSCUMM.vcw b/backends/wince/PocketSCUMM.vcw
new file mode 100644
index 0000000000..9961cf0d39
--- /dev/null
+++ b/backends/wince/PocketSCUMM.vcw
@@ -0,0 +1,29 @@
+Microsoft eMbedded Visual Tools Workspace File, Format Version 3.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "PocketSCUMM"=.\PocketSCUMM.vcp - Package Owner=<4>
+
+Package=<5>
+{{{
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
diff --git a/backends/wince/bitmaps.cpp b/backends/wince/bitmaps.cpp
new file mode 100644
index 0000000000..3b23330fde
--- /dev/null
+++ b/backends/wince/bitmaps.cpp
@@ -0,0 +1,10720 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#ifdef _WIN32_WCE
+
+// Bitmaps used for WCE
+
+#include <windows.h>
+#include "screen.h"
+
+// Loading
+
+unsigned char item_loading_colors[] = { 
+	0x04, 0x02, 0x04, 
+	0x21, 0x11, 0x1d, 
+	0x40, 0x21, 0x37, 
+	0x2c, 0x17, 0x26, 
+	0x7d, 0x41, 0x6b, 
+	0xf6, 0x80, 0xd3, 
+	0xb9, 0x60, 0x9f, 
+	0x90, 0x4b, 0x7c, 
+	0x18, 0x0c, 0x15, 
+	0x9b, 0x51, 0x85, 
+	0x5e, 0x31, 0x51, 
+	0xcd, 0x6b, 0xb0, 
+	0xe1, 0x75, 0xc1, 
+	0x36, 0x1c, 0x2f, 
+	0xc3, 0x65, 0xa7, 
+	0x4a, 0x27, 0x40, 
+	0xd8, 0x70, 0xb9, 
+	0x72, 0x3b, 0x62, 
+	0x55, 0x2c, 0x49, 
+	0x87, 0x46, 0x74, 
+	0xaf, 0x5b, 0x96, 
+	0xec, 0x7b, 0xca, 
+	0x69, 0x36, 0x5a, 
+	0xa5, 0x56, 0x8e
+
+};
+unsigned char item_loading[] = { 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 
+	0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x06, 0x00, 0x00, 0x06, 0x05, 0x05, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 
+	0x05, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x06, 0x00, 0x00, 0x06, 0x05, 
+	0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x04, 0x05, 0x06, 0x00, 0x00, 0x07, 
+	0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x02, 0x02, 0x08, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 0x06, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x05, 0x02, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x08, 0x09, 0x05, 0x05, 0x05, 
+	0x05, 0x09, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 
+	0x0b, 0x05, 0x0c, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x0d, 0x0b, 0x05, 0x0c, 0x09, 0x09, 0x05, 0x06, 0x00, 
+	0x00, 0x07, 0x06, 0x06, 0x00, 0x00, 0x07, 0x06, 0x06, 
+	0x08, 0x07, 0x0c, 0x05, 0x0e, 0x03, 0x00, 0x00, 0x00, 
+	0x00, 0x0f, 0x0b, 0x05, 0x05, 0x0b, 0x04, 0x04, 0x04, 
+	0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x04, 0x05, 0x05, 0x02, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x08, 0x0b, 0x05, 0x05, 0x0b, 
+	0x0b, 0x05, 0x05, 0x0b, 0x00, 0x00, 0x00, 0x03, 0x10, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x11, 0x00, 0x00, 0x00, 
+	0x12, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 
+	0x00, 0x00, 0x06, 0x05, 0x05, 0x00, 0x00, 0x06, 0x05, 
+	0x05, 0x0b, 0x05, 0x05, 0x05, 0x05, 0x10, 0x00, 0x00, 
+	0x00, 0x12, 0x05, 0x05, 0x09, 0x13, 0x0c, 0x05, 0x05, 
+	0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 0x05, 0x02, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 0x05, 0x12, 
+	0x00, 0x00, 0x04, 0x05, 0x05, 0x0a, 0x00, 0x00, 0x12, 
+	0x05, 0x14, 0x01, 0x08, 0x14, 0x05, 0x06, 0x00, 0x00, 
+	0x03, 0x05, 0x05, 0x05, 0x14, 0x04, 0x0e, 0x05, 0x05, 
+	0x06, 0x00, 0x00, 0x06, 0x05, 0x05, 0x00, 0x00, 0x06, 
+	0x05, 0x05, 0x05, 0x0e, 0x13, 0x0c, 0x05, 0x05, 0x03, 
+	0x00, 0x00, 0x0c, 0x05, 0x04, 0x00, 0x00, 0x0d, 0x05, 
+	0x15, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 0x05, 0x02, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x05, 0x0b, 
+	0x00, 0x00, 0x00, 0x00, 0x05, 0x05, 0x06, 0x00, 0x00, 
+	0x00, 0x02, 0x00, 0x00, 0x00, 0x04, 0x05, 0x06, 0x00, 
+	0x00, 0x09, 0x05, 0x05, 0x16, 0x00, 0x00, 0x00, 0x13, 
+	0x05, 0x06, 0x00, 0x00, 0x06, 0x05, 0x05, 0x00, 0x00, 
+	0x06, 0x05, 0x05, 0x16, 0x00, 0x00, 0x13, 0x05, 0x05, 
+	0x02, 0x00, 0x00, 0x05, 0x05, 0x02, 0x00, 0x00, 0x00, 
+	0x05, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 0x05, 
+	0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x05, 0x05, 
+	0x13, 0x00, 0x00, 0x00, 0x00, 0x06, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x11, 0x14, 0x10, 0x05, 0x06, 
+	0x00, 0x00, 0x0c, 0x05, 0x10, 0x00, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x06, 0x00, 0x00, 0x06, 0x05, 0x05, 0x00, 
+	0x00, 0x06, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 
+	0x05, 0x02, 0x00, 0x00, 0x0c, 0x05, 0x04, 0x00, 0x00, 
+	0x0d, 0x05, 0x05, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 
+	0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x05, 
+	0x05, 0x04, 0x00, 0x00, 0x00, 0x00, 0x06, 0x05, 0x05, 
+	0x00, 0x00, 0x00, 0x07, 0x05, 0x05, 0x10, 0x10, 0x05, 
+	0x06, 0x00, 0x00, 0x05, 0x05, 0x06, 0x00, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x06, 0x00, 0x00, 0x06, 0x05, 0x05, 
+	0x00, 0x00, 0x06, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 
+	0x05, 0x05, 0x02, 0x00, 0x00, 0x12, 0x05, 0x05, 0x13, 
+	0x13, 0x0c, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 
+	0x05, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 
+	0x05, 0x05, 0x04, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x05, 
+	0x05, 0x00, 0x00, 0x14, 0x05, 0x0b, 0x0d, 0x00, 0x04, 
+	0x05, 0x06, 0x00, 0x00, 0x05, 0x05, 0x10, 0x00, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x06, 0x00, 0x00, 0x06, 0x05, 
+	0x05, 0x00, 0x00, 0x06, 0x05, 0x05, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x05, 0x02, 0x00, 0x00, 0x0f, 0x0c, 0x15, 
+	0x05, 0x05, 0x10, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x05, 0x05, 0x0b, 0x00, 0x00, 0x00, 0x08, 0x05, 
+	0x05, 0x14, 0x00, 0x03, 0x05, 0x05, 0x01, 0x00, 0x00, 
+	0x04, 0x05, 0x06, 0x00, 0x00, 0x06, 0x05, 0x05, 0x0d, 
+	0x00, 0x00, 0x00, 0x13, 0x05, 0x06, 0x00, 0x00, 0x06, 
+	0x05, 0x05, 0x00, 0x00, 0x06, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x05, 0x02, 0x00, 0x17, 0x05, 0x14, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x05, 0x16, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x00, 0x09, 0x05, 0x05, 0x12, 0x00, 0x00, 0x17, 
+	0x05, 0x05, 0x0a, 0x00, 0x02, 0x05, 0x05, 0x01, 0x00, 
+	0x08, 0x0b, 0x05, 0x06, 0x00, 0x00, 0x0a, 0x05, 0x05, 
+	0x0c, 0x11, 0x02, 0x04, 0x05, 0x05, 0x06, 0x00, 0x00, 
+	0x06, 0x05, 0x05, 0x00, 0x00, 0x06, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x05, 0x02, 0x02, 0x05, 0x05, 
+	0x0c, 0x06, 0x04, 0x11, 0x02, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x06, 
+	0x06, 0x03, 0x00, 0x00, 0x07, 0x06, 0x06, 0x00, 0x00, 
+	0x00, 0x06, 0x06, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x06, 0x00, 0x08, 0x0c, 0x05, 0x05, 0x06, 0x10, 
+	0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x0c, 0x05, 0x0c, 
+	0x06, 0x0c, 0x05, 0x05, 0x05, 0x04, 0x0d, 0x00, 0x0b, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x00, 
+	0x00, 0x06, 0x05, 0x05, 0x00, 0x00, 0x06, 0x05, 0x05, 
+	0x00, 0x00, 0x00, 0x04, 0x05, 0x05, 0x02, 0x00, 0x09, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x0e, 0x03, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 
+	0x05, 0x05, 0x02, 0x00, 0x00, 0x06, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x05, 0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x06, 0x00, 0x00, 0x03, 0x0e, 0x05, 0x05, 
+	0x05, 0x0c, 0x04, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0c, 
+	0x05, 0x05, 0x10, 0x02, 0x0c, 0x05, 0x05, 0x11, 0x00, 
+	0x08, 0x0e, 0x05, 0x05, 0x05, 0x10, 0x17, 0x05, 0x06, 
+	0x00, 0x00, 0x06, 0x05, 0x05, 0x00, 0x00, 0x06, 0x05, 
+	0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x05, 0x02, 0x00, 
+	0x00, 0x04, 0x05, 0x0e, 0x06, 0x0b, 0x05, 0x05, 0x05, 
+	0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x05, 0x02, 0x00, 0x00, 0x06, 0x05, 0x05, 
+	0x00, 0x00, 0x00, 0x05, 0x05, 0x06, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x00, 0x00, 0x08, 0x02, 0x08, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x00, 0x01, 0x02, 
+	0x03, 0x00, 0x00, 0x03, 0x02, 0x02, 0x00, 0x00, 0x03, 
+	0x02, 0x02, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x08, 
+	0x00, 0x17, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x17, 
+	0x05, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x02, 0x02, 0x08, 0x00, 0x00, 0x03, 0x02, 
+	0x02, 0x00, 0x00, 0x00, 0x02, 0x02, 0x03, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x03, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x05, 0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x05, 0x05, 0x0d, 0x00, 0x00, 0x00, 
+	0x00, 0x14, 0x05, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x0b, 0x05, 0x05, 0x09, 0x04, 
+	0x13, 0x10, 0x05, 0x0c, 0x03, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x09, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x09, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 
+};
+
+// *************************************************************************
+//									PORTRAIT				
+// *************************************************************************
+
+unsigned char item_toolbarPortrait_colors[] = { 
+	0x00, 0x00, 0x00, 
+	0x04, 0x02, 0x04, 
+	0x0c, 0x02, 0x04, 
+	0x24, 0x06, 0x04, 
+	0x84, 0x16, 0x14, 
+	0x9c, 0x1a, 0x1c, 
+	0x74, 0x16, 0x14, 
+	0x1c, 0x06, 0x04, 
+	0x5c, 0x0e, 0x0c, 
+	0x4c, 0x0e, 0x0c, 
+	0x44, 0x0a, 0x0c, 
+	0x64, 0x12, 0x14, 
+	0x8c, 0x1a, 0x1c, 
+	0xc4, 0x22, 0x24, 
+	0xb4, 0x1e, 0x1c, 
+	0x0c, 0x06, 0x04, 
+	0xa4, 0x1e, 0x1c, 
+	0x34, 0x0a, 0x0c, 
+	0x14, 0x16, 0x14, 
+	0x64, 0x66, 0x64, 
+	0x1c, 0x16, 0x1c, 
+	0x1c, 0x1a, 0x1c, 
+	0x3c, 0x3e, 0x3c, 
+	0x34, 0x36, 0x34, 
+	0x34, 0x32, 0x34, 
+	0x6c, 0x6a, 0x6c, 
+	0xb4, 0xb2, 0xb4, 
+	0x4c, 0x4e, 0x4c, 
+	0x94, 0x92, 0x94, 
+	0x94, 0x96, 0x94, 
+	0x7c, 0x7e, 0x7c, 
+	0x9c, 0x9e, 0x9c, 
+	0x0c, 0x0a, 0x0c, 
+	0x44, 0x46, 0x44, 
+	0x5c, 0x5a, 0x5c, 
+	0x74, 0x76, 0x74, 
+	0xc4, 0xc2, 0xc4, 
+	0x84, 0x82, 0x84, 
+	0x9c, 0x9a, 0x9c, 
+	0x74, 0x72, 0x74, 
+	0x24, 0x26, 0x24, 
+	0xa4, 0xa6, 0xa4, 
+	0x3c, 0x3a, 0x3c, 
+	0x8c, 0x8e, 0x8c, 
+	0x2c, 0x7e, 0xb4, 
+	0xbc, 0xbe, 0xbc, 
+	0x6c, 0x6e, 0x6c, 
+	0x1c, 0x1e, 0x1c, 
+	0x2c, 0x5e, 0x7c, 
+	0xac, 0xaa, 0xac, 
+	0x5c, 0x5e, 0x5c, 
+	0xa4, 0xa2, 0xa4, 
+	0xd4, 0xd6, 0xd4, 
+	0xac, 0xae, 0xac, 
+	0xec, 0xee, 0xec, 
+	0xe4, 0xe6, 0xe4, 
+	0xfc, 0xfa, 0xfc, 
+	0x1c, 0x0a, 0x0c, 
+	0x2c, 0x0e, 0x0c, 
+	0x24, 0x0a, 0x0c, 
+	0x14, 0x06, 0x04, 
+	0x34, 0x0e, 0x0c, 
+	0xcc, 0xce, 0xcc, 
+	0xf4, 0xf2, 0xf4, 
+	0x0c, 0x0a, 0x04, 
+	0x24, 0x1a, 0x0c, 
+	0x2c, 0x1e, 0x14, 
+	0x24, 0x1e, 0x0c, 
+	0x24, 0x1e, 0x14, 
+	0x1c, 0x16, 0x0c, 
+	0x14, 0x0e, 0x04, 
+	0x04, 0x06, 0x04, 
+	0x14, 0x12, 0x0c, 
+	0x5c, 0x1a, 0x1c, 
+	0x94, 0x26, 0x24, 
+	0xb4, 0x2e, 0x2c, 
+	0xd4, 0x3a, 0x3c, 
+	0xcc, 0x36, 0x34, 
+	0xa4, 0x2e, 0x2c, 
+	0x54, 0x16, 0x14, 
+	0x4c, 0x16, 0x14, 
+	0x7c, 0x22, 0x24, 
+	0x9c, 0x2a, 0x2c, 
+	0xbc, 0x36, 0x34, 
+	0xb4, 0x32, 0x34, 
+	0xac, 0x2e, 0x2c, 
+	0x2c, 0x0a, 0x0c, 
+	0xa4, 0x2a, 0x2c, 
+	0x6c, 0x1e, 0x1c, 
+	0x64, 0x1e, 0x1c, 
+	0x94, 0x2a, 0x2c, 
+	0x34, 0x22, 0x24, 
+	0x64, 0x4a, 0x24, 
+	0xc4, 0x96, 0x4c, 
+	0xd4, 0xa2, 0x54, 
+	0xcc, 0x9e, 0x54, 
+	0x84, 0x66, 0x34, 
+	0x14, 0x0e, 0x0c, 
+	0xec, 0xb2, 0x5c, 
+	0xdc, 0xaa, 0x5c, 
+	0x94, 0x72, 0x3c, 
+	0xe4, 0xb2, 0x5c, 
+	0x4c, 0x3a, 0x1c, 
+	0xc4, 0x36, 0x34, 
+	0xbc, 0x32, 0x34, 
+	0xc4, 0x32, 0x34, 
+	0x8c, 0x26, 0x24, 
+	0x44, 0x12, 0x14, 
+	0x74, 0x1e, 0x1c, 
+	0x5c, 0x16, 0x14, 
+	0xb4, 0x86, 0x44, 
+	0xfc, 0xc6, 0x6c, 
+	0xf4, 0xbe, 0x64, 
+	0xf4, 0xba, 0x64, 
+	0xfc, 0xbe, 0x64, 
+	0xec, 0xb6, 0x64, 
+	0x2c, 0x22, 0x14, 
+	0xfc, 0xce, 0x6c, 
+	0xfc, 0xc2, 0x64, 
+	0xcc, 0x9a, 0x54, 
+	0xdc, 0xa6, 0x54, 
+	0xfc, 0xd2, 0x6c, 
+	0x5c, 0x46, 0x24, 
+	0xcc, 0x3a, 0x3c, 
+	0x84, 0x22, 0x24, 
+	0x84, 0x26, 0x24, 
+	0xdc, 0xde, 0xdc, 
+	0xe4, 0xe2, 0xe4, 
+	0x5c, 0x4a, 0x2c, 
+	0xec, 0xb6, 0x5c, 
+	0x9c, 0x7a, 0x3c, 
+	0xfc, 0xc6, 0x64, 
+	0x34, 0x26, 0x14, 
+	0x4c, 0x12, 0x14, 
+	0x64, 0x1a, 0x1c, 
+	0x54, 0x3e, 0x24, 
+	0xf4, 0xb6, 0x64, 
+	0x6c, 0x56, 0x2c, 
+	0x3c, 0x2a, 0x14, 
+	0x44, 0x32, 0x1c, 
+	0xac, 0x32, 0x34, 
+	0x54, 0x1a, 0x1c, 
+	0x3c, 0x12, 0x14, 
+	0xe4, 0xae, 0x5c, 
+	0x6c, 0x52, 0x2c, 
+	0x74, 0x5a, 0x34, 
+	0xc4, 0x9a, 0x54, 
+	0x7c, 0x62, 0x34, 
+	0x84, 0x62, 0x34, 
+	0xbc, 0xba, 0xbc, 
+	0x7c, 0x5e, 0x34, 
+	0x8c, 0x66, 0x34, 
+	0x9c, 0x76, 0x3c, 
+	0x94, 0x6e, 0x3c, 
+	0x8c, 0x6a, 0x3c, 
+	0x74, 0x22, 0x24, 
+	0xbc, 0x8e, 0x4c, 
+	0xb4, 0x8a, 0x4c, 
+	0xb4, 0x8e, 0x4c, 
+	0x44, 0x36, 0x1c, 
+	0x7c, 0x5a, 0x34, 
+	0x8c, 0x6a, 0x34, 
+	0x74, 0x56, 0x2c, 
+	0x5c, 0x4a, 0x24, 
+	0xbc, 0x92, 0x4c, 
+	0xe4, 0xaa, 0x5c, 
+	0x64, 0x4e, 0x2c, 
+	0x54, 0x3e, 0x1c, 
+	0x8c, 0x6e, 0x3c, 
+	0x0c, 0x06, 0x0c, 
+	0xa4, 0x7e, 0x44, 
+	0x94, 0x76, 0x3c, 
+	0x9c, 0x2e, 0x34, 
+	0x8c, 0x2a, 0x2c, 
+	0x8c, 0x8a, 0x8c, 
+	0x54, 0x42, 0x24, 
+	0x4c, 0x3e, 0x1c, 
+	0xd4, 0xa6, 0x54, 
+	0x1c, 0x1a, 0x0c, 
+	0x2c, 0x2e, 0x2c, 
+	0xac, 0x82, 0x44
+
+};
+unsigned char item_toolbarPortrait[] = { 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x03, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x06, 0x07, 0x01, 0x01, 0x01, 0x01, 0x02, 0x08, 
+	0x06, 0x04, 0x05, 0x08, 0x09, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x07, 0x08, 0x04, 0x04, 0x04, 0x06, 
+	0x0a, 0x01, 0x0b, 0x04, 0x05, 0x04, 0x01, 0x01, 0x01, 
+	0x08, 0x04, 0x04, 0x05, 0x03, 0x03, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x0c, 0x04, 0x0c, 0x08, 0x03, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x04, 0x05, 0x04, 0x05, 0x0b, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 
+	0x0d, 0x0e, 0x0d, 0x0e, 0x0d, 0x0e, 0x0d, 0x0e, 0x0f, 
+	0x01, 0x01, 0x08, 0x0d, 0x0e, 0x0d, 0x0d, 0x0e, 0x0d, 
+	0x0d, 0x10, 0x03, 0x01, 0x01, 0x01, 0x02, 0x06, 0x0d, 
+	0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x05, 0x01, 0x04, 0x0d, 
+	0x0d, 0x0e, 0x01, 0x01, 0x11, 0x0d, 0x0d, 0x0d, 0x08, 
+	0x01, 0x03, 0x0d, 0x0e, 0x0d, 0x0d, 0x0e, 0x0d, 0x0d, 
+	0x0e, 0x08, 0x11, 0x0d, 0x0e, 0x0d, 0x0e, 0x0d, 0x0d, 
+	0x0d, 0x0e, 0x0d, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x11, 0x0d, 0x0d, 0x05, 0x11, 
+	0x0a, 0x0e, 0x0d, 0x0e, 0x08, 0x01, 0x06, 0x0e, 0x0d, 
+	0x0d, 0x0e, 0x04, 0x0e, 0x0e, 0x0d, 0x0d, 0x0e, 0x02, 
+	0x01, 0x01, 0x05, 0x0e, 0x0d, 0x0d, 0x0e, 0x05, 0x04, 
+	0x04, 0x04, 0x01, 0x05, 0x0e, 0x0d, 0x0d, 0x01, 0x02, 
+	0x0e, 0x0e, 0x0d, 0x04, 0x01, 0x01, 0x11, 0x0d, 0x0d, 
+	0x0d, 0x0b, 0x08, 0x08, 0x08, 0x08, 0x11, 0x02, 0x08, 
+	0x08, 0x08, 0x0d, 0x0d, 0x0e, 0x06, 0x08, 0x08, 0x0a, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x11, 0x0e, 0x0d, 0x04, 0x01, 0x01, 0x04, 0x0d, 0x0d, 
+	0x08, 0x11, 0x0d, 0x0d, 0x0d, 0x04, 0x02, 0x01, 0x01, 
+	0x0a, 0x0d, 0x0e, 0x0d, 0x06, 0x01, 0x08, 0x0e, 0x0d, 
+	0x0d, 0x06, 0x07, 0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 
+	0x0d, 0x0d, 0x0e, 0x01, 0x06, 0x0d, 0x0d, 0x0e, 0x02, 
+	0x01, 0x01, 0x11, 0x0e, 0x0d, 0x0d, 0x11, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x0e, 0x0d, 
+	0x0d, 0x11, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x12, 0x12, 0x12, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x11, 0x0d, 0x0d, 0x04, 
+	0x01, 0x03, 0x0d, 0x0d, 0x0e, 0x0a, 0x0b, 0x0d, 0x0e, 
+	0x0d, 0x02, 0x01, 0x01, 0x01, 0x01, 0x04, 0x0d, 0x0d, 
+	0x0e, 0x01, 0x05, 0x0d, 0x0d, 0x10, 0x02, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x04, 0x0d, 0x0d, 0x0e, 0x08, 
+	0x0d, 0x0d, 0x0e, 0x03, 0x01, 0x01, 0x01, 0x11, 0x0d, 
+	0x0d, 0x0e, 0x05, 0x05, 0x04, 0x0c, 0x09, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x0d, 0x0d, 0x0d, 0x03, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x13, 0x13, 0x14, 0x12, 0x15, 0x16, 
+	0x17, 0x18, 0x12, 0x14, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x01, 0x03, 0x0d, 0x0e, 0x0b, 0x10, 0x0d, 0x0d, 0x0e, 
+	0x05, 0x01, 0x04, 0x0d, 0x0d, 0x04, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x08, 0x0e, 0x0d, 0x0d, 0x01, 0x0d, 0x0d, 
+	0x0e, 0x08, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x04, 0x0d, 0x0d, 0x04, 0x10, 0x0d, 0x0e, 0x05, 0x01, 
+	0x01, 0x01, 0x01, 0x03, 0x0d, 0x0e, 0x0d, 0x0d, 0x0d, 
+	0x0e, 0x0d, 0x08, 0x01, 0x01, 0x01, 0x01, 0x03, 0x0e, 
+	0x0d, 0x0d, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x13, 0x19, 0x13, 0x1a, 
+	0x19, 0x1b, 0x13, 0x1c, 0x1d, 0x1e, 0x18, 0x17, 0x18, 
+	0x13, 0x19, 0x13, 0x19, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, 0x0d, 0x0d, 
+	0x08, 0x06, 0x0e, 0x0e, 0x06, 0x02, 0x01, 0x04, 0x0d, 
+	0x0d, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x06, 0x0d, 
+	0x0e, 0x0e, 0x01, 0x0e, 0x0d, 0x0d, 0x08, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x04, 0x0d, 0x0e, 0x05, 
+	0x0a, 0x0d, 0x0d, 0x0d, 0x0a, 0x01, 0x01, 0x01, 0x08, 
+	0x0d, 0x0d, 0x0d, 0x0b, 0x08, 0x08, 0x08, 0x03, 0x01, 
+	0x01, 0x01, 0x01, 0x11, 0x0d, 0x0d, 0x0e, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x19, 
+	0x19, 0x1a, 0x1f, 0x1f, 0x1e, 0x20, 0x21, 0x22, 0x23, 
+	0x24, 0x1a, 0x25, 0x13, 0x19, 0x1f, 0x1f, 0x1a, 0x1a, 
+	0x19, 0x19, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x08, 0x0d, 0x0e, 0x08, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x08, 0x0d, 0x0e, 0x0d, 0x03, 0x01, 
+	0x01, 0x01, 0x02, 0x0e, 0x0d, 0x0d, 0x04, 0x01, 0x05, 
+	0x0e, 0x0d, 0x0e, 0x02, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x05, 0x0d, 0x0d, 0x04, 0x01, 0x04, 0x0d, 0x0e, 
+	0x0e, 0x02, 0x01, 0x01, 0x08, 0x0d, 0x0e, 0x0d, 0x11, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 
+	0x0d, 0x0d, 0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x26, 0x1a, 0x1f, 0x27, 0x27, 
+	0x28, 0x01, 0x18, 0x18, 0x17, 0x13, 0x1f, 0x1a, 0x29, 
+	0x1c, 0x2a, 0x2b, 0x1f, 0x26, 0x1a, 0x1f, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x0b, 0x0e, 
+	0x0d, 0x08, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x07, 
+	0x0d, 0x0d, 0x0d, 0x0e, 0x08, 0x11, 0x09, 0x0e, 0x0d, 
+	0x0e, 0x0d, 0x03, 0x01, 0x08, 0x0d, 0x0d, 0x0e, 0x10, 
+	0x09, 0x0a, 0x03, 0x08, 0x03, 0x01, 0x0d, 0x0d, 0x0d, 
+	0x04, 0x01, 0x02, 0x0e, 0x0d, 0x0d, 0x04, 0x01, 0x01, 
+	0x08, 0x0d, 0x0d, 0x0e, 0x08, 0x03, 0x11, 0x11, 0x08, 
+	0x01, 0x01, 0x01, 0x01, 0x08, 0x0d, 0x0d, 0x0e, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x2a, 0x1f, 0x29, 0x1c, 0x1d, 0x01, 0x01, 0x17, 0x2c, 
+	0x18, 0x18, 0x2d, 0x1e, 0x1a, 0x2b, 0x01, 0x29, 0x29, 
+	0x2b, 0x1f, 0x17, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x08, 0x0d, 0x0d, 0x08, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x0a, 0x0d, 0x0d, 0x0e, 
+	0x0d, 0x0e, 0x0d, 0x0e, 0x0d, 0x0d, 0x09, 0x01, 0x01, 
+	0x01, 0x0b, 0x0d, 0x0d, 0x0d, 0x0e, 0x0d, 0x0d, 0x0d, 
+	0x11, 0x01, 0x0e, 0x0d, 0x0d, 0x04, 0x01, 0x01, 0x08, 
+	0x0d, 0x0e, 0x0d, 0x08, 0x01, 0x06, 0x0e, 0x0d, 0x0d, 
+	0x0d, 0x0d, 0x0d, 0x0e, 0x0d, 0x01, 0x01, 0x01, 0x01, 
+	0x08, 0x0d, 0x0e, 0x0d, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17, 0x26, 0x26, 
+	0x1a, 0x2e, 0x2f, 0x18, 0x30, 0x17, 0x18, 0x31, 0x32, 
+	0x1a, 0x2b, 0x27, 0x1a, 0x1f, 0x2b, 0x1c, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 
+	0x0d, 0x0e, 0x08, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x03, 0x06, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 
+	0x04, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x08, 0x05, 
+	0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x02, 0x01, 0x0d, 0x0e, 
+	0x0d, 0x04, 0x01, 0x01, 0x01, 0x0e, 0x0e, 0x0d, 0x0e, 
+	0x03, 0x04, 0x0d, 0x0e, 0x0d, 0x0e, 0x0d, 0x0e, 0x0d, 
+	0x05, 0x01, 0x01, 0x01, 0x01, 0x04, 0x0e, 0x0d, 0x0e, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x18, 0x1c, 0x1f, 0x26, 0x33, 0x16, 
+	0x18, 0x17, 0x1f, 0x34, 0x35, 0x1a, 0x27, 0x1a, 0x1f, 
+	0x2b, 0x2b, 0x18, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x03, 0x11, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x11, 0x03, 0x11, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x2e, 0x2b, 0x1c, 0x23, 0x21, 0x17, 0x1f, 0x36, 0x37, 
+	0x34, 0x1e, 0x1e, 0x26, 0x2b, 0x1c, 0x18, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x15, 0x1c, 0x2b, 0x2b, 
+	0x2b, 0x29, 0x34, 0x38, 0x36, 0x2d, 0x1d, 0x2b, 0x1c, 
+	0x2b, 0x2e, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x07, 
+	0x39, 0x3a, 0x3a, 0x3a, 0x3b, 0x39, 0x39, 0x02, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x3c, 
+	0x07, 0x3b, 0x3d, 0x3a, 0x3d, 0x3b, 0x07, 0x39, 0x01, 
+	0x01, 0x01, 0x07, 0x39, 0x03, 0x39, 0x3b, 0x39, 0x3c, 
+	0x01, 0x01, 0x01, 0x01, 0x02, 0x3b, 0x39, 0x39, 0x03, 
+	0x39, 0x07, 0x0f, 0x01, 0x01, 0x02, 0x07, 0x3b, 0x39, 
+	0x39, 0x07, 0x3b, 0x39, 0x07, 0x02, 0x01, 0x01, 0x01, 
+	0x3c, 0x3b, 0x07, 0x39, 0x07, 0x3b, 0x07, 0x39, 0x03, 
+	0x01, 0x01, 0x01, 0x3c, 0x3b, 0x07, 0x3b, 0x39, 0x03, 
+	0x39, 0x39, 0x3b, 0x01, 0x01, 0x01, 0x01, 0x07, 0x39, 
+	0x03, 0x39, 0x2e, 0x2b, 0x1a, 0x3e, 0x3f, 0x3f, 0x38, 
+	0x38, 0x37, 0x3e, 0x31, 0x2b, 0x1c, 0x15, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x40, 0x41, 0x42, 0x43, 0x43, 
+	0x43, 0x44, 0x45, 0x01, 0x43, 0x44, 0x41, 0x43, 0x44, 
+	0x41, 0x43, 0x42, 0x46, 0x47, 0x01, 0x01, 0x48, 0x43, 
+	0x43, 0x41, 0x43, 0x44, 0x41, 0x42, 0x43, 0x40, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x01, 0x01, 0x07, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4c, 
+	0x4d, 0x4b, 0x4e, 0x4f, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x3b, 0x50, 0x51, 0x52, 0x53, 0x4d, 0x4c, 
+	0x4d, 0x54, 0x55, 0x4e, 0x56, 0x01, 0x01, 0x54, 0x55, 
+	0x57, 0x4e, 0x4e, 0x4b, 0x58, 0x02, 0x01, 0x01, 0x01, 
+	0x59, 0x57, 0x4e, 0x55, 0x57, 0x4e, 0x57, 0x50, 0x01, 
+	0x01, 0x4f, 0x54, 0x57, 0x4e, 0x55, 0x57, 0x4e, 0x57, 
+	0x4e, 0x4f, 0x01, 0x01, 0x07, 0x5a, 0x55, 0x4e, 0x55, 
+	0x4e, 0x57, 0x55, 0x57, 0x55, 0x01, 0x01, 0x01, 0x58, 
+	0x55, 0x57, 0x4e, 0x4e, 0x4e, 0x55, 0x4e, 0x4b, 0x56, 
+	0x01, 0x01, 0x02, 0x55, 0x55, 0x57, 0x4e, 0x5b, 0x1c, 
+	0x1a, 0x36, 0x38, 0x38, 0x38, 0x38, 0x38, 0x34, 0x1a, 
+	0x2b, 0x27, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x5c, 0x5d, 0x5e, 0x5e, 0x5f, 0x5e, 0x5e, 0x60, 0x61, 
+	0x62, 0x5e, 0x5e, 0x5e, 0x5e, 0x5e, 0x5e, 0x63, 0x64, 
+	0x40, 0x01, 0x01, 0x64, 0x5e, 0x5e, 0x5e, 0x5e, 0x5e, 
+	0x5e, 0x5f, 0x65, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x4e, 0x4d, 
+	0x67, 0x67, 0x68, 0x68, 0x69, 0x68, 0x67, 0x4d, 0x6a, 
+	0x3c, 0x01, 0x01, 0x01, 0x01, 0x02, 0x50, 0x4e, 0x4c, 
+	0x4d, 0x67, 0x69, 0x68, 0x68, 0x69, 0x67, 0x67, 0x4d, 
+	0x6b, 0x01, 0x01, 0x4d, 0x67, 0x67, 0x67, 0x67, 0x4d, 
+	0x51, 0x01, 0x01, 0x01, 0x01, 0x6c, 0x53, 0x67, 0x67, 
+	0x67, 0x67, 0x68, 0x6d, 0x01, 0x01, 0x58, 0x4c, 0x67, 
+	0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x6c, 0x01, 0x01, 
+	0x3d, 0x67, 0x4d, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 
+	0x4c, 0x01, 0x01, 0x01, 0x6c, 0x4c, 0x67, 0x67, 0x69, 
+	0x67, 0x67, 0x67, 0x4c, 0x50, 0x01, 0x01, 0x50, 0x67, 
+	0x67, 0x67, 0x67, 0x67, 0x2b, 0x1a, 0x38, 0x38, 0x38, 
+	0x38, 0x38, 0x38, 0x34, 0x1a, 0x2b, 0x32, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x40, 0x6e, 0x6f, 0x70, 0x71, 
+	0x72, 0x70, 0x73, 0x74, 0x43, 0x75, 0x71, 0x70, 0x71, 
+	0x70, 0x72, 0x71, 0x76, 0x77, 0x48, 0x01, 0x01, 0x78, 
+	0x70, 0x70, 0x71, 0x72, 0x71, 0x70, 0x72, 0x79, 0x7a, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x3c, 0x52, 0x67, 0x68, 0x68, 0x68, 0x53, 0x68, 
+	0x53, 0x68, 0x68, 0x7b, 0x7c, 0x3c, 0x01, 0x01, 0x01, 
+	0x3c, 0x7d, 0x4d, 0x67, 0x4b, 0x69, 0x68, 0x53, 0x68, 
+	0x53, 0x68, 0x68, 0x68, 0x67, 0x6b, 0x01, 0x3b, 0x67, 
+	0x68, 0x68, 0x67, 0x68, 0x7b, 0x6d, 0x01, 0x01, 0x01, 
+	0x01, 0x6c, 0x68, 0x67, 0x4b, 0x53, 0x68, 0x54, 0x3d, 
+	0x01, 0x01, 0x51, 0x67, 0x67, 0x4b, 0x68, 0x67, 0x68, 
+	0x53, 0x68, 0x4a, 0x01, 0x01, 0x49, 0x4c, 0x4b, 0x53, 
+	0x68, 0x68, 0x53, 0x68, 0x68, 0x4b, 0x01, 0x01, 0x02, 
+	0x4a, 0x67, 0x68, 0x67, 0x53, 0x68, 0x68, 0x68, 0x4d, 
+	0x49, 0x01, 0x01, 0x7c, 0x53, 0x68, 0x68, 0x53, 0x68, 
+	0x68, 0x26, 0x7e, 0x38, 0x38, 0x38, 0x38, 0x7f, 0x2d, 
+	0x1a, 0x1c, 0x80, 0x46, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x66, 0x63, 0x71, 0x81, 0x71, 0x81, 0x71, 0x82, 0x01, 
+	0x7a, 0x83, 0x71, 0x81, 0x71, 0x81, 0x73, 0x81, 0x71, 
+	0x65, 0x46, 0x01, 0x84, 0x70, 0x71, 0x81, 0x71, 0x81, 
+	0x71, 0x81, 0x81, 0x70, 0x66, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85, 0x68, 0x68, 
+	0x53, 0x69, 0x68, 0x68, 0x67, 0x4d, 0x4d, 0x7b, 0x4d, 
+	0x6a, 0x3c, 0x01, 0x01, 0x02, 0x51, 0x4d, 0x53, 0x69, 
+	0x53, 0x68, 0x53, 0x69, 0x67, 0x4d, 0x7b, 0x4d, 0x4d, 
+	0x4c, 0x86, 0x01, 0x3d, 0x4d, 0x68, 0x53, 0x4b, 0x67, 
+	0x4d, 0x49, 0x01, 0x01, 0x01, 0x01, 0x7c, 0x4b, 0x67, 
+	0x68, 0x68, 0x69, 0x55, 0x3d, 0x01, 0x02, 0x6c, 0x4d, 
+	0x53, 0x68, 0x53, 0x4b, 0x67, 0x68, 0x68, 0x54, 0x01, 
+	0x02, 0x7d, 0x67, 0x68, 0x68, 0x68, 0x67, 0x68, 0x68, 
+	0x67, 0x4a, 0x01, 0x01, 0x02, 0x52, 0x67, 0x68, 0x4b, 
+	0x67, 0x68, 0x67, 0x68, 0x67, 0x7c, 0x0f, 0x01, 0x55, 
+	0x68, 0x67, 0x68, 0x68, 0x67, 0x68, 0x2b, 0x7e, 0x38, 
+	0x38, 0x38, 0x38, 0x34, 0x1a, 0x1d, 0x2b, 0x65, 0x87, 
+	0x01, 0x01, 0x01, 0x01, 0x47, 0x64, 0x72, 0x81, 0x71, 
+	0x81, 0x73, 0x62, 0x43, 0x01, 0x7a, 0x6f, 0x81, 0x88, 
+	0x81, 0x88, 0x81, 0x71, 0x81, 0x75, 0x74, 0x01, 0x89, 
+	0x71, 0x81, 0x88, 0x81, 0x73, 0x81, 0x71, 0x70, 0x78, 
+	0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x58, 0x68, 0x67, 0x4b, 0x53, 0x67, 0x68, 
+	0x7d, 0x6d, 0x49, 0x58, 0x4a, 0x5a, 0x07, 0x01, 0x01, 
+	0x86, 0x4d, 0x67, 0x68, 0x68, 0x68, 0x68, 0x67, 0x54, 
+	0x7c, 0x86, 0x6d, 0x49, 0x6c, 0x7d, 0x4f, 0x01, 0x3d, 
+	0x67, 0x68, 0x68, 0x68, 0x68, 0x7b, 0x6d, 0x01, 0x01, 
+	0x01, 0x01, 0x55, 0x53, 0x68, 0x68, 0x53, 0x68, 0x55, 
+	0x3a, 0x01, 0x02, 0x51, 0x4d, 0x68, 0x69, 0x68, 0x67, 
+	0x68, 0x68, 0x53, 0x4b, 0x0f, 0x3c, 0x4b, 0x69, 0x68, 
+	0x53, 0x67, 0x4b, 0x53, 0x68, 0x67, 0x4a, 0x01, 0x01, 
+	0x02, 0x4a, 0x69, 0x68, 0x68, 0x67, 0x4b, 0x53, 0x68, 
+	0x67, 0x4a, 0x02, 0x3b, 0x68, 0x67, 0x4b, 0x68, 0x67, 
+	0x4b, 0x53, 0x68, 0x2d, 0x7e, 0x38, 0x38, 0x38, 0x34, 
+	0x1a, 0x1c, 0x73, 0x81, 0x64, 0x01, 0x01, 0x01, 0x01, 
+	0x8b, 0x78, 0x70, 0x88, 0x81, 0x71, 0x76, 0x60, 0x01, 
+	0x01, 0x7a, 0x76, 0x71, 0x81, 0x71, 0x81, 0x71, 0x81, 
+	0x88, 0x6f, 0x66, 0x01, 0x6e, 0x73, 0x71, 0x81, 0x71, 
+	0x81, 0x88, 0x81, 0x70, 0x63, 0x8a, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x68, 
+	0x53, 0x68, 0x69, 0x4b, 0x54, 0x85, 0x01, 0x01, 0x01, 
+	0x3c, 0x3d, 0x02, 0x01, 0x07, 0x8c, 0x68, 0x4b, 0x67, 
+	0x68, 0x68, 0x67, 0x4a, 0x3d, 0x0f, 0x01, 0x01, 0x01, 
+	0x01, 0x02, 0x3c, 0x01, 0x3d, 0x67, 0x68, 0x53, 0x68, 
+	0x67, 0x67, 0x8d, 0x01, 0x01, 0x01, 0x01, 0x57, 0x68, 
+	0x67, 0x68, 0x68, 0x69, 0x55, 0x8e, 0x01, 0x0f, 0x7c, 
+	0x67, 0x68, 0x53, 0x68, 0x4b, 0x67, 0x68, 0x68, 0x54, 
+	0x3d, 0x3a, 0x7b, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 
+	0x68, 0x67, 0x4a, 0x01, 0x01, 0x01, 0x55, 0x67, 0x68, 
+	0x53, 0x68, 0x68, 0x68, 0x68, 0x67, 0x68, 0x0f, 0x86, 
+	0x53, 0x68, 0x53, 0x67, 0x68, 0x68, 0x68, 0x68, 0x1a, 
+	0x34, 0x38, 0x38, 0x38, 0x7e, 0x1a, 0x2b, 0x73, 0x81, 
+	0x5f, 0x01, 0x01, 0x01, 0x01, 0x60, 0x76, 0x88, 0x81, 
+	0x71, 0x81, 0x8f, 0x46, 0x01, 0x01, 0x90, 0x83, 0x73, 
+	0x81, 0x88, 0x81, 0x81, 0x73, 0x81, 0x76, 0x91, 0x46, 
+	0x73, 0x81, 0x88, 0x81, 0x73, 0x81, 0x71, 0x81, 0x70, 
+	0x63, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x3d, 0x69, 0x68, 0x68, 0x53, 0x68, 
+	0x68, 0x4a, 0x56, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x6d, 0x4b, 0x53, 0x68, 0x53, 0x68, 0x53, 0x52, 0x07, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x6b, 0x67, 0x68, 0x68, 0x68, 0x67, 0x55, 0x09, 0x01, 
+	0x01, 0x01, 0x01, 0x4e, 0x67, 0x4b, 0x53, 0x68, 0x53, 
+	0x4e, 0x07, 0x01, 0x07, 0x5a, 0x67, 0x68, 0x68, 0x68, 
+	0x52, 0x68, 0x68, 0x53, 0x4b, 0x85, 0x49, 0x4d, 0x53, 
+	0x69, 0x4e, 0x55, 0x69, 0x68, 0x53, 0x69, 0x4a, 0x01, 
+	0x01, 0x3c, 0x67, 0x68, 0x68, 0x68, 0x55, 0x55, 0x67, 
+	0x68, 0x68, 0x4d, 0x01, 0x6a, 0x69, 0x68, 0x68, 0x54, 
+	0x4a, 0x69, 0x53, 0x68, 0x1a, 0x34, 0x38, 0x38, 0x7e, 
+	0x34, 0x1a, 0x2b, 0x81, 0x71, 0x78, 0x84, 0x01, 0x01, 
+	0x43, 0x92, 0x76, 0x81, 0x73, 0x81, 0x76, 0x93, 0x01, 
+	0x01, 0x47, 0x60, 0x72, 0x71, 0x81, 0x71, 0x5e, 0x78, 
+	0x71, 0x73, 0x76, 0x94, 0x66, 0x81, 0x73, 0x81, 0x65, 
+	0x5d, 0x71, 0x88, 0x81, 0x70, 0x78, 0x8a, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x7c, 0x67, 0x68, 0x68, 0x68, 0x67, 0x67, 0x57, 0x50, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x51, 0x53, 0x69, 0x68, 
+	0x68, 0x68, 0x68, 0x4f, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x6d, 0x67, 0x68, 0x53, 
+	0x68, 0x67, 0x54, 0x6b, 0x01, 0x01, 0x01, 0x01, 0x57, 
+	0x68, 0x68, 0x69, 0x68, 0x67, 0x57, 0x0f, 0x01, 0x07, 
+	0x4a, 0x67, 0x68, 0x67, 0x67, 0x6a, 0x54, 0x53, 0x68, 
+	0x68, 0x58, 0x7d, 0x67, 0x68, 0x67, 0x6a, 0x6a, 0x67, 
+	0x68, 0x68, 0x67, 0x5a, 0x01, 0x01, 0x01, 0x4d, 0x67, 
+	0x68, 0x53, 0x57, 0x52, 0x53, 0x68, 0x53, 0x4d, 0x8e, 
+	0x4b, 0x53, 0x68, 0x68, 0x6a, 0x5a, 0x67, 0x68, 0x68, 
+	0x26, 0x95, 0x7e, 0x38, 0x7e, 0x34, 0x1a, 0x1c, 0x81, 
+	0x71, 0x65, 0x96, 0x01, 0x01, 0x90, 0x70, 0x81, 0x71, 
+	0x81, 0x71, 0x8f, 0x45, 0x01, 0x01, 0x47, 0x97, 0x76, 
+	0x73, 0x81, 0x70, 0x92, 0x77, 0x71, 0x81, 0x72, 0x98, 
+	0x99, 0x73, 0x81, 0x71, 0x8f, 0x9a, 0x76, 0x81, 0x71, 
+	0x71, 0x78, 0x8b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x3c, 0x6a, 0x4d, 0x53, 
+	0x68, 0x53, 0x4b, 0x67, 0x68, 0x86, 0x01, 0x01, 0x01, 
+	0x01, 0x4e, 0x4b, 0x68, 0x67, 0x68, 0x53, 0x4e, 0x07, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x49, 0x67, 0x68, 0x68, 0x68, 0x68, 0x4b, 0x3d, 
+	0x01, 0x01, 0x01, 0x3c, 0x4e, 0x69, 0x68, 0x53, 0x68, 
+	0x53, 0x57, 0x3c, 0x01, 0x3b, 0x52, 0x67, 0x68, 0x68, 
+	0x67, 0x58, 0x4b, 0x68, 0x67, 0x4b, 0x7d, 0x4b, 0x68, 
+	0x68, 0x69, 0x86, 0x51, 0x4d, 0x53, 0x68, 0x68, 0x4a, 
+	0x01, 0x01, 0x3b, 0x4d, 0x68, 0x68, 0x67, 0x57, 0x6a, 
+	0x55, 0x69, 0x68, 0x67, 0x9b, 0x4b, 0x68, 0x53, 0x54, 
+	0x6d, 0x4a, 0x67, 0x68, 0x53, 0x2b, 0x1a, 0x7e, 0x7e, 
+	0x34, 0x95, 0x1d, 0x2b, 0x81, 0x71, 0x81, 0x9c, 0x01, 
+	0x45, 0x9d, 0x76, 0x71, 0x81, 0x71, 0x76, 0x64, 0x01, 
+	0x01, 0x01, 0x47, 0x82, 0x72, 0x71, 0x81, 0x70, 0x6e, 
+	0x9e, 0x72, 0x81, 0x70, 0x6e, 0x5f, 0x81, 0x71, 0x81, 
+	0x5d, 0x7a, 0x83, 0x73, 0x81, 0x70, 0x63, 0x8a, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x01, 0x01, 0x3c, 0x51, 0x4d, 0x68, 0x67, 0x68, 0x68, 
+	0x67, 0x67, 0x86, 0x01, 0x01, 0x01, 0x4e, 0x68, 0x53, 
+	0x4b, 0x67, 0x68, 0x4e, 0x0f, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x6d, 0x67, 0x68, 
+	0x53, 0x68, 0x67, 0x54, 0x6b, 0x01, 0x01, 0x01, 0x3c, 
+	0x55, 0x53, 0x68, 0x68, 0x68, 0x68, 0x4e, 0x3c, 0x01, 
+	0x3d, 0x55, 0x69, 0x68, 0x53, 0x4d, 0x3b, 0x4b, 0x53, 
+	0x68, 0x53, 0x55, 0x68, 0x53, 0x69, 0x4e, 0x49, 0x7c, 
+	0x67, 0x68, 0x68, 0x67, 0x4a, 0x01, 0x01, 0x3d, 0x4d, 
+	0x53, 0x68, 0x67, 0x5a, 0x4f, 0x52, 0x67, 0x68, 0x67, 
+	0x55, 0x68, 0x68, 0x68, 0x4b, 0x3a, 0x69, 0x68, 0x68, 
+	0x69, 0x1c, 0x1d, 0x95, 0x34, 0x95, 0x1d, 0x2b, 0x1c, 
+	0x88, 0x81, 0x71, 0x5f, 0x46, 0x9f, 0x76, 0x71, 0x81, 
+	0x88, 0x81, 0x76, 0x84, 0x01, 0x01, 0x01, 0x40, 0x5d, 
+	0x71, 0x81, 0x71, 0x76, 0xa0, 0xa1, 0x76, 0x73, 0x71, 
+	0x5e, 0x81, 0x88, 0x81, 0x73, 0x99, 0xa2, 0x6f, 0x88, 
+	0x81, 0x70, 0x78, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 
+	0x6c, 0x67, 0x68, 0x68, 0x67, 0x68, 0x68, 0x67, 0x50, 
+	0x01, 0x01, 0x52, 0x68, 0x69, 0x68, 0x67, 0x68, 0x55, 
+	0x3b, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x7d, 0x69, 0x68, 0x68, 0x68, 0x67, 0x4b, 
+	0x3d, 0x01, 0x01, 0x01, 0x3a, 0x4b, 0x68, 0x68, 0x69, 
+	0x53, 0x67, 0x4e, 0x3c, 0x01, 0x8e, 0x55, 0x67, 0x68, 
+	0x68, 0x4c, 0x02, 0x4e, 0x68, 0x68, 0x68, 0x68, 0x68, 
+	0x68, 0x67, 0x6a, 0x6b, 0x5a, 0x67, 0x68, 0x69, 0x67, 
+	0x58, 0x01, 0x01, 0x8e, 0x4d, 0x68, 0x68, 0x67, 0x6a, 
+	0x85, 0x5a, 0x67, 0x68, 0x67, 0x4b, 0x53, 0x68, 0x53, 
+	0x4e, 0x02, 0x4c, 0x68, 0x53, 0x1d, 0x2b, 0x2b, 0x1a, 
+	0x34, 0x1a, 0x2b, 0x1c, 0x35, 0x81, 0x71, 0x81, 0x63, 
+	0x5c, 0x9a, 0x83, 0x88, 0x81, 0x73, 0x76, 0x82, 0x0f, 
+	0x01, 0x01, 0x01, 0x40, 0x5d, 0x70, 0x88, 0x81, 0x6f, 
+	0x5c, 0x89, 0x72, 0x71, 0x81, 0x73, 0x81, 0x73, 0x81, 
+	0x8f, 0xa3, 0x9a, 0x76, 0x81, 0x71, 0x72, 0x9d, 0x41, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x50, 0x67, 0x68, 
+	0x4b, 0x67, 0x68, 0x4d, 0x4a, 0x07, 0x01, 0x6c, 0x53, 
+	0x68, 0x53, 0x4b, 0x67, 0x68, 0x6c, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x6a, 0x67, 
+	0x53, 0x69, 0x68, 0x53, 0x68, 0x6b, 0x01, 0x01, 0x01, 
+	0x3d, 0x54, 0x68, 0x67, 0x53, 0x4b, 0x67, 0x4a, 0x01, 
+	0x01, 0x3d, 0x69, 0x53, 0x68, 0x53, 0x4d, 0x3c, 0x7c, 
+	0x53, 0x68, 0x67, 0x53, 0x68, 0x68, 0x4d, 0x6c, 0x39, 
+	0x4a, 0x67, 0x68, 0x53, 0x67, 0x86, 0x01, 0x01, 0x4f, 
+	0x67, 0x69, 0x53, 0x69, 0x4a, 0x3d, 0x51, 0x67, 0x68, 
+	0x68, 0x68, 0x68, 0x69, 0x4b, 0x86, 0x3c, 0x4d, 0x67, 
+	0x1d, 0x1a, 0x2b, 0x1c, 0x1a, 0x95, 0x1a, 0x2b, 0x2b, 
+	0x1a, 0x1d, 0x81, 0x71, 0x65, 0xa4, 0x5e, 0x71, 0x81, 
+	0x71, 0x71, 0x70, 0x84, 0x01, 0x01, 0x01, 0x01, 0x40, 
+	0xa5, 0x71, 0x81, 0x71, 0x83, 0xa6, 0xa7, 0x65, 0x81, 
+	0x71, 0x81, 0x71, 0x81, 0x71, 0x8f, 0x46, 0xa8, 0x76, 
+	0x88, 0x81, 0x76, 0x9d, 0x45, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, 0x03, 0x01, 
+	0x01, 0x01, 0x02, 0x7c, 0x4d, 0x53, 0x68, 0x68, 0x67, 
+	0x55, 0x3b, 0x01, 0x50, 0x4b, 0x68, 0x68, 0x53, 0x68, 
+	0x67, 0x4b, 0x6c, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x3a, 0x07, 0x01, 0x4a, 0x67, 0x4b, 0x68, 0x67, 0x68, 
+	0x67, 0x51, 0x01, 0x01, 0x01, 0x6a, 0x68, 0x67, 0x4b, 
+	0x69, 0x68, 0x53, 0x52, 0x01, 0x01, 0x4f, 0x4c, 0x68, 
+	0x68, 0x69, 0x4d, 0x3c, 0x49, 0x4b, 0x67, 0x4b, 0x68, 
+	0x68, 0x53, 0x68, 0x50, 0x3c, 0x52, 0x67, 0x68, 0x68, 
+	0x4d, 0x6d, 0x01, 0x01, 0x86, 0x67, 0x68, 0x68, 0x67, 
+	0x52, 0x39, 0x58, 0x4d, 0x53, 0x68, 0x67, 0x68, 0x53, 
+	0x68, 0x3d, 0x3c, 0x4c, 0x1d, 0x1a, 0x1a, 0x35, 0x2b, 
+	0x1d, 0x19, 0x19, 0x1c, 0x35, 0x1a, 0x1a, 0x1d, 0x81, 
+	0x73, 0x81, 0x73, 0x81, 0x88, 0x81, 0x83, 0x82, 0x46, 
+	0x01, 0x01, 0x01, 0x01, 0x46, 0x6f, 0x81, 0x71, 0x81, 
+	0x6f, 0x90, 0x74, 0x5e, 0x71, 0x81, 0x88, 0x81, 0x71, 
+	0x81, 0x6e, 0x01, 0x64, 0x76, 0x73, 0x81, 0x76, 0x6e, 
+	0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x54, 0x4b, 0x68, 0x7d, 0x7c, 0x4a, 0x67, 
+	0x68, 0x68, 0x69, 0x53, 0x67, 0x52, 0x07, 0x01, 0x01, 
+	0x4e, 0x68, 0x53, 0x68, 0x68, 0x68, 0x53, 0x53, 0x4b, 
+	0x52, 0x7c, 0x7c, 0x55, 0x68, 0x67, 0x07, 0x01, 0x6c, 
+	0x67, 0x68, 0x53, 0x4b, 0x67, 0x67, 0x67, 0x4e, 0x7c, 
+	0x55, 0x68, 0x53, 0x67, 0x68, 0x53, 0x68, 0x68, 0x6c, 
+	0x01, 0x01, 0x50, 0x4d, 0x68, 0x53, 0x68, 0x67, 0x02, 
+	0x50, 0x68, 0x68, 0x68, 0x67, 0x68, 0x67, 0x57, 0x3a, 
+	0x07, 0x52, 0x67, 0x68, 0x53, 0x67, 0x86, 0x01, 0x01, 
+	0x86, 0x67, 0x68, 0x68, 0x67, 0x4a, 0x3c, 0x86, 0x4d, 
+	0x68, 0x68, 0x4b, 0x67, 0x68, 0x4b, 0x01, 0x3c, 0x1f, 
+	0x1a, 0x1a, 0x1d, 0x1d, 0x13, 0xa9, 0x47, 0x01, 0x13, 
+	0x19, 0x1a, 0x1a, 0x1a, 0x1f, 0x71, 0x81, 0x81, 0x88, 
+	0x81, 0x71, 0x71, 0x8a, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x46, 0x6f, 0x81, 0x88, 0x81, 0x76, 0x5c, 0x41, 0x92, 
+	0x70, 0x73, 0x81, 0x71, 0x81, 0x73, 0xa2, 0x01, 0x64, 
+	0x76, 0x81, 0x88, 0x76, 0x9d, 0x45, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4b, 0x69, 
+	0x53, 0x69, 0x53, 0x68, 0x53, 0x68, 0x53, 0x68, 0x68, 
+	0x4d, 0x6c, 0x02, 0x01, 0x01, 0x8e, 0x4b, 0x69, 0x53, 
+	0x68, 0x67, 0x4b, 0x69, 0x68, 0x53, 0x69, 0x53, 0x68, 
+	0x68, 0x4d, 0x02, 0x01, 0x85, 0x67, 0x68, 0x68, 0x68, 
+	0x67, 0x4b, 0x68, 0x68, 0x67, 0x67, 0x68, 0x67, 0x4b, 
+	0x68, 0x68, 0x68, 0x55, 0x56, 0x01, 0x01, 0x86, 0x7b, 
+	0x68, 0x68, 0x67, 0x4e, 0x02, 0x3a, 0x68, 0x53, 0x68, 
+	0x68, 0x68, 0x67, 0x6a, 0x01, 0x07, 0x4a, 0x67, 0x68, 
+	0x68, 0x67, 0x86, 0x01, 0x01, 0x51, 0x67, 0x53, 0x68, 
+	0x67, 0x7c, 0x01, 0x6b, 0x4b, 0x67, 0x68, 0x53, 0x68, 
+	0x68, 0x7c, 0x01, 0x07, 0x1a, 0x1a, 0x13, 0x13, 0x13, 
+	0x50, 0x01, 0x01, 0x01, 0x47, 0x32, 0x19, 0x13, 0x1c, 
+	0xaa, 0x81, 0x88, 0x71, 0x81, 0x71, 0x76, 0xab, 0x46, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x84, 0x76, 0x71, 0x81, 
+	0x71, 0x8f, 0x66, 0x01, 0x9d, 0x72, 0x81, 0x71, 0x81, 
+	0x73, 0x81, 0x74, 0x0f, 0x64, 0x76, 0x71, 0x73, 0x72, 
+	0x6e, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x54, 0x68, 0x68, 0x68, 0x68, 0x69, 
+	0x68, 0x68, 0x69, 0x53, 0x67, 0x4e, 0x03, 0x01, 0x01, 
+	0x01, 0x01, 0x3d, 0x54, 0x4b, 0x67, 0x68, 0x68, 0x53, 
+	0x68, 0x68, 0x68, 0x68, 0x68, 0x67, 0x52, 0x02, 0x01, 
+	0x01, 0x7c, 0x67, 0x53, 0x68, 0x53, 0x68, 0x53, 0x53, 
+	0x68, 0x4b, 0x67, 0x68, 0x53, 0x68, 0x53, 0x4b, 0x50, 
+	0x01, 0x01, 0x02, 0x6c, 0x4d, 0x68, 0x68, 0x67, 0x57, 
+	0x02, 0x02, 0x4b, 0x68, 0x68, 0x53, 0x68, 0x67, 0x59, 
+	0x01, 0x56, 0x57, 0x67, 0x68, 0x68, 0x67, 0x86, 0x01, 
+	0x01, 0x4a, 0x69, 0x68, 0x68, 0x67, 0x7d, 0x01, 0x3d, 
+	0x4e, 0x69, 0x68, 0x68, 0x68, 0x67, 0x50, 0x01, 0x3b, 
+	0xac, 0xad, 0xae, 0xae, 0xae, 0x1e, 0x01, 0x01, 0x01, 
+	0x01, 0xae, 0xae, 0xae, 0x5f, 0x71, 0x81, 0x81, 0x81, 
+	0x73, 0x81, 0x88, 0x8b, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0xaf, 0x76, 0x88, 0x81, 0x71, 0x8f, 0xb0, 0x01, 
+	0x82, 0x72, 0x81, 0x71, 0x81, 0x81, 0xb1, 0x01, 0x40, 
+	0xaa, 0x76, 0x81, 0x81, 0x76, 0x9d, 0x45, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4e, 
+	0x69, 0x53, 0x69, 0x68, 0x68, 0x68, 0x53, 0x53, 0x4b, 
+	0x52, 0x56, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x3c, 
+	0x7c, 0x54, 0x68, 0x68, 0x68, 0x68, 0x68, 0x69, 0x53, 
+	0x69, 0x67, 0x6a, 0x01, 0x01, 0x01, 0x01, 0x6d, 0x54, 
+	0x4b, 0x68, 0x68, 0x67, 0x4b, 0x69, 0x53, 0x68, 0x53, 
+	0x68, 0x4b, 0x52, 0x3d, 0x01, 0x01, 0x01, 0x02, 0x7c, 
+	0x4d, 0x53, 0x67, 0x67, 0x57, 0x3c, 0x01, 0x54, 0x67, 
+	0x67, 0x68, 0x53, 0x55, 0x09, 0x01, 0x6b, 0x54, 0x67, 
+	0x67, 0x53, 0x67, 0x86, 0x01, 0x01, 0x55, 0x67, 0x67, 
+	0x67, 0x4d, 0x7c, 0x01, 0x07, 0x4e, 0x69, 0x53, 0x67, 
+	0x53, 0x68, 0x07, 0x01, 0x50, 0x4d, 0x53, 0x54, 0x2b, 
+	0x2a, 0x16, 0x01, 0x01, 0x01, 0x01, 0x2a, 0x16, 0x2a, 
+	0x71, 0x81, 0x71, 0x71, 0x71, 0x71, 0x83, 0xab, 0x46, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x5c, 0x76, 0x70, 
+	0x81, 0x70, 0x8f, 0xa7, 0x01, 0x64, 0x76, 0x71, 0x71, 
+	0x71, 0x71, 0xa1, 0x01, 0x48, 0x5e, 0x70, 0x71, 0x71, 
+	0x76, 0x9d, 0xb2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x58, 0x4a, 0x52, 0x4e, 0x55, 
+	0x4e, 0x55, 0x57, 0x6a, 0x85, 0x02, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x03, 0x59, 0x4a, 
+	0x4e, 0x4e, 0x55, 0x4e, 0x57, 0x57, 0x4a, 0x50, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x02, 0x4f, 0x7c, 0x57, 0x4e, 
+	0x57, 0x4e, 0x57, 0x57, 0x52, 0x6c, 0x6b, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x3c, 0x6c, 0x4e, 0x52, 0x4a, 0x4e, 
+	0x7c, 0x02, 0x01, 0x6c, 0x52, 0x4a, 0x4e, 0x52, 0x7c, 
+	0x07, 0x01, 0x3d, 0x4a, 0x52, 0x4a, 0x4e, 0x57, 0x4f, 
+	0x01, 0x01, 0x4e, 0x52, 0x4a, 0x52, 0x57, 0x58, 0x01, 
+	0x02, 0x6c, 0x4e, 0x52, 0x4a, 0x57, 0x7d, 0x01, 0x01, 
+	0x3d, 0xb3, 0x18, 0xb3, 0x2a, 0x18, 0x18, 0xb3, 0x01, 
+	0x01, 0xb3, 0x18, 0x18, 0x18, 0xb3, 0x18, 0xb3, 0x5d, 
+	0x5d, 0x77, 0x5d, 0x8b, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x90, 0x5f, 0x5d, 0x5d, 0x5f, 0x9c, 0x8b, 
+	0x01, 0x7a, 0x5d, 0x5d, 0x5d, 0x5d, 0x77, 0x9f, 0x01, 
+	0x46, 0xb4, 0x77, 0x5d, 0x5d, 0x5e, 0x64, 0x46, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x01, 0x01, 0x01, 0x02, 0x3c, 0x3c, 0x3c, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x07, 0x3c, 0x3c, 
+	0x3c, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01 
+};
+
+// Keyboard
+
+unsigned char item_keyboardPortrait_colors[] = { 
+	0x00, 0x00, 0x00, 
+	0x18, 0x18, 0x18, 
+	0x39, 0x39, 0x39, 
+	0x31, 0x31, 0x31, 
+	0x29, 0x29, 0x29, 
+	0x21, 0x21, 0x21, 
+	0x42, 0x42, 0x42, 
+	0x63, 0x63, 0x63, 
+	0x7b, 0x7b, 0x7b, 
+	0x73, 0x73, 0x73, 
+	0x6b, 0x6b, 0x6b, 
+	0x4a, 0x4a, 0x4a, 
+	0x94, 0x94, 0x94, 
+	0x9c, 0x9c, 0x9c, 
+	0xa5, 0xa5, 0xa5, 
+	0xbd, 0xbd, 0xbd, 
+	0x5a, 0x5a, 0x5a, 
+	0x52, 0x52, 0x52, 
+	0x84, 0x84, 0x84, 
+	0xad, 0xad, 0xad, 
+	0xc6, 0xc6, 0xc6, 
+	0xb5, 0xb5, 0xb5, 
+	0x8c, 0x8c, 0x8c, 
+	0x10, 0x10, 0x10, 
+	0x08, 0x08, 0x08
+
+};
+unsigned char item_keyboardPortrait[] = { 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 
+	0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 
+	0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 
+	0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 
+	0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 
+	0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 
+	0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 
+	0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 
+	0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 
+	0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 
+	0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 
+	0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x05, 0x02, 0x06, 0x02, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 
+	0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 
+	0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x01, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x07, 0x08, 0x06, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x09, 0x08, 0x03, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x0a, 0x08, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x08, 0x07, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x0b, 0x0c, 0x0d, 0x0d, 
+	0x0b, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x06, 0x0a, 0x08, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x0e, 0x0f, 0x10, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x0f, 0x0f, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x0a, 0x08, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x0d, 0x0e, 
+	0x0d, 0x0b, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 
+	0x0a, 0x0d, 0x0e, 0x0d, 0x11, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x0a, 0x0d, 0x0e, 0x0d, 
+	0x0d, 0x0d, 0x06, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x0a, 0x0d, 0x0e, 0x0d, 0x0d, 0x0d, 0x10, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x11, 0x0d, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x10, 0x0d, 0x0d, 0x0d, 0x0d, 0x07, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 
+	0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x0e, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 
+	0x06, 0x06, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 
+	0x0b, 0x0e, 0x13, 0x08, 0x08, 0x06, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x12, 0x0e, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x07, 0x12, 
+	0x0b, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x06, 0x0b, 0x06, 0x06, 0x08, 0x09, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x0e, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x08, 0x12, 0x0f, 0x10, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x06, 0x06, 0x0b, 0x10, 0x12, 0x12, 0x0f, 
+	0x10, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x10, 0x12, 0x12, 0x08, 0x08, 0x13, 0x08, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x10, 0x12, 0x12, 
+	0x08, 0x08, 0x0d, 0x0d, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x07, 0x0f, 0x06, 0x06, 0x07, 0x08, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x07, 
+	0x14, 0x08, 0x12, 0x08, 0x0b, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 
+	0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x06, 0x06, 0x0b, 0x06, 0x11, 0x11, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x12, 0x0d, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x0d, 
+	0x08, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 
+	0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x0f, 0x07, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x0d, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x12, 0x0d, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 
+	0x06, 0x0f, 0x07, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 
+	0x0b, 0x0b, 0x06, 0x06, 0x0f, 0x07, 0x02, 0x03, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x06, 0x06, 
+	0x06, 0x06, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x0b, 0x06, 0x06, 0x06, 0x06, 0x08, 0x0d, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x07, 0x14, 
+	0x06, 0x06, 0x08, 0x0d, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x0b, 0x07, 0x0f, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 
+	0x0b, 0x06, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 
+	0x11, 0x13, 0x07, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x10, 0x0f, 0x0f, 0x14, 0x0e, 0x06, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x13, 
+	0x0e, 0x0f, 0x14, 0x08, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x06, 0x11, 0x0e, 0x0f, 0x14, 0x0f, 
+	0x0c, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 
+	0x12, 0x0f, 0x0f, 0x0e, 0x13, 0x08, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x06, 0x12, 0x0f, 0x0f, 0x14, 
+	0x12, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x10, 0x0f, 0x0f, 0x0f, 0x15, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x12, 0x0f, 0x0f, 
+	0x0e, 0x0e, 0x09, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x12, 0x0e, 0x12, 0x15, 0x0f, 0x0e, 0x06, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x15, 0x0f, 
+	0x0f, 0x11, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x0b, 0x0d, 0x0f, 0x14, 0x15, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x0e, 
+	0x06, 0x06, 0x09, 0x15, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x0f, 0x10, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0d, 
+	0x0d, 0x0f, 0x0e, 0x0e, 0x15, 0x07, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 
+	0x0f, 0x10, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x0d, 0x08, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 
+	0x06, 0x06, 0x02, 0x08, 0x0d, 0x03, 0x03, 0x03, 0x00, 
+	0x06, 0x06, 0x0b, 0x07, 0x0f, 0x06, 0x06, 0x08, 0x0d, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 
+	0x07, 0x14, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x0b, 0x0c, 0x13, 0x06, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x06, 0x06, 0x11, 0x13, 0x0f, 0x07, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x07, 0x07, 0x10, 0x13, 0x09, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x12, 0x0f, 0x0c, 0x07, 0x0a, 0x15, 
+	0x0a, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x11, 
+	0x13, 0x13, 0x07, 0x10, 0x10, 0x0b, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x06, 0x09, 0x15, 0x09, 0x07, 0x16, 
+	0x0f, 0x08, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 
+	0x09, 0x15, 0x08, 0x07, 0x09, 0x0f, 0x0a, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x07, 0x14, 0x09, 
+	0x11, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x09, 0x15, 0x09, 0x07, 0x16, 0x0f, 0x08, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x12, 0x0f, 0x13, 
+	0x09, 0x10, 0x13, 0x09, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x10, 0x07, 0x0f, 0x07, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x11, 0x07, 0x09, 0x0f, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x12, 0x0d, 0x06, 0x0c, 0x15, 0x11, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x14, 0x10, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x06, 0x0e, 0x15, 0x09, 0x0f, 0x0e, 
+	0x16, 0x0d, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x14, 0x10, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x11, 0x08, 
+	0x12, 0x08, 0x08, 0x13, 0x08, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x06, 0x0b, 0x12, 0x12, 0x08, 0x13, 
+	0x16, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x07, 
+	0x0f, 0x06, 0x06, 0x12, 0x0d, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x06, 0x06, 0x07, 0x0f, 0x12, 0x08, 
+	0x08, 0x06, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x0c, 
+	0x0f, 0x0f, 0x13, 0x06, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x0b, 
+	0x13, 0x0f, 0x0f, 0x09, 0x10, 0x11, 0x11, 0x11, 0x0b, 
+	0x0b, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x06, 0x06, 0x06, 0x10, 0x12, 0x08, 0x08, 0x13, 
+	0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 
+	0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x12, 0x13, 0x0b, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x12, 0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x0d, 0x06, 0x02, 
+	0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x06, 0x06, 0x0f, 0x10, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x0d, 0x06, 
+	0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x06, 0x06, 0x12, 0x0e, 0x06, 0x02, 0x02, 0x0d, 0x08, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x0f, 0x10, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x10, 0x0f, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 
+	0x0e, 0x0d, 0x13, 0x11, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x0f, 0x10, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x0d, 0x12, 0x06, 0x0f, 0x10, 0x08, 0x0d, 0x03, 0x03, 
+	0x03, 0x00, 0x00, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x0f, 0x10, 0x11, 0x10, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x06, 0x08, 0x15, 0x0d, 0x0e, 0x0d, 0x0d, 
+	0x0b, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 
+	0x11, 0x0d, 0x0d, 0x0d, 0x15, 0x08, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x07, 0x0f, 0x12, 0x08, 0x0d, 
+	0x13, 0x06, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x10, 0x0d, 0x0d, 0x0d, 0x15, 0x09, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x06, 0x06, 0x0c, 0x14, 0x0f, 0x0f, 0x0f, 0x13, 
+	0x06, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x02, 0x10, 0x15, 0x0f, 0x0f, 0x0e, 
+	0x0e, 0x0d, 0x0e, 0x0d, 0x0d, 0x0c, 0x06, 0x04, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x06, 0x11, 
+	0x0f, 0x0d, 0x0d, 0x0d, 0x14, 0x09, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x02, 0x06, 0x08, 0x0d, 0x02, 0x02, 0x02, 
+	0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 
+	0x08, 0x0d, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x02, 0x06, 0x08, 0x0d, 0x06, 0x02, 
+	0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 
+	0x06, 0x08, 0x15, 0x0d, 0x0d, 0x0d, 0x15, 0x08, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x02, 0x02, 0x14, 
+	0x10, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x02, 0x06, 0x08, 0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x08, 0x0d, 
+	0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x02, 0x06, 0x02, 0x02, 0x06, 0x0f, 0x10, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x02, 
+	0x02, 0x06, 0x02, 0x10, 0x0f, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x02, 0x06, 0x08, 0x0f, 0x0f, 0x0c, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 
+	0x02, 0x02, 0x06, 0x0f, 0x10, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x02, 0x06, 0x0d, 0x08, 0x02, 0x0f, 
+	0x10, 0x08, 0x0d, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x06, 0x02, 0x02, 0x06, 0x0f, 0x10, 0x08, 
+	0x0d, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x02, 0x08, 
+	0x0d, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x02, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x08, 0x0d, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 
+	0x11, 0x0d, 0x0d, 0x0d, 0x13, 0x15, 0x06, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x02, 0x02, 0x06, 0x02, 0x02, 
+	0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x0c, 0x0f, 
+	0x0f, 0x14, 0x0f, 0x0f, 0x0f, 0x0e, 0x02, 0x03, 0x03, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 
+	0x02, 0x11, 0x15, 0x0f, 0x07, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x02, 0x08, 0x0e, 0x02, 0x02, 0x02, 
+	0x16, 0x0d, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 
+	0x08, 0x0d, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x08, 0x13, 0x06, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x02, 0x08, 0x0d, 0x02, 0x02, 0x02, 0x0e, 0x08, 0x03, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x08, 0x13, 0x08, 
+	0x08, 0x08, 0x08, 0x0b, 0x03, 0x04, 0x04, 0x00, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x0f, 0x10, 0x02, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x08, 0x13, 
+	0x02, 0x02, 0x0b, 0x13, 0x08, 0x03, 0x04, 0x04, 0x00, 
+	0x02, 0x02, 0x02, 0x08, 0x0d, 0x02, 0x02, 0x02, 0x08, 
+	0x0d, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x0f, 0x10, 0x03, 0x03, 0x03, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x10, 
+	0x0f, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 
+	0x08, 0x13, 0x10, 0x15, 0x0c, 0x03, 0x03, 0x03, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0f, 
+	0x10, 0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x02, 0x0d, 0x08, 0x02, 0x14, 0x10, 0x11, 0x0f, 0x03, 
+	0x04, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x0f, 0x10, 0x08, 0x0d, 0x03, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x02, 0x08, 0x0d, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x08, 0x0d, 0x03, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x08, 0x0d, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x03, 
+	0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x02, 0x10, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 
+	0x08, 0x08, 0x07, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x11, 0x15, 
+	0x10, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x03, 
+	0x09, 0x13, 0x10, 0x10, 0x07, 0x13, 0x0d, 0x04, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x08, 0x0f, 0x16, 0x10, 
+	0x0a, 0x15, 0x07, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x03, 0x06, 0x13, 0x0e, 0x10, 0x11, 0x11, 0x06, 0x03, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x0a, 0x15, 0x0a, 
+	0x10, 0x0c, 0x0f, 0x08, 0x04, 0x04, 0x04, 0x00, 0x02, 
+	0x02, 0x03, 0x0a, 0x15, 0x0a, 0x10, 0x11, 0x10, 0x02, 
+	0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x02, 0x02, 
+	0x0f, 0x10, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x00, 
+	0x02, 0x02, 0x02, 0x06, 0x15, 0x13, 0x0d, 0x0f, 0x15, 
+	0x09, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x08, 
+	0x0d, 0x02, 0x03, 0x03, 0x08, 0x0d, 0x04, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x03, 0x02, 0x0b, 0x10, 0x0f, 0x0a, 
+	0x10, 0x03, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 
+	0x02, 0x02, 0x03, 0x02, 0x11, 0x14, 0x03, 0x04, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x08, 0x0d, 0x02, 0x06, 
+	0x0e, 0x0c, 0x02, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x03, 0x02, 0x0b, 0x10, 0x0f, 0x0a, 0x10, 0x03, 0x04, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x02, 
+	0x0f, 0x10, 0x11, 0x0f, 0x03, 0x04, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x03, 0x06, 0x10, 0x10, 0x0f, 0x0a, 
+	0x16, 0x0d, 0x04, 0x04, 0x04, 0x00, 0x02, 0x03, 0x02, 
+	0x08, 0x13, 0x10, 0x11, 0x10, 0x11, 0x02, 0x03, 0x04, 
+	0x04, 0x00, 0x02, 0x03, 0x02, 0x06, 0x10, 0x10, 0x10, 
+	0x11, 0x16, 0x0d, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x03, 0x02, 0x02, 0x02, 0x03, 0x08, 0x0d, 0x03, 0x04, 
+	0x04, 0x04, 0x00, 0x02, 0x03, 0x02, 0x07, 0x16, 0x10, 
+	0x10, 0x11, 0x0e, 0x08, 0x04, 0x04, 0x04, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 
+	0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x03, 0x02, 0x0b, 0x0b, 0x02, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x03, 0x03, 0x06, 0x0e, 0x0f, 0x0f, 
+	0x15, 0x0d, 0x0c, 0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x09, 0x0e, 0x0e, 0x0f, 0x0f, 0x08, 0x04, 0x03, 
+	0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x06, 0x0e, 
+	0x0f, 0x14, 0x0f, 0x0c, 0x04, 0x04, 0x04, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x08, 0x0f, 0x0f, 0x0c, 0x0e, 0x0a, 
+	0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x0a, 
+	0x15, 0x0f, 0x0f, 0x0f, 0x09, 0x04, 0x04, 0x04, 0x00, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 0x0b, 0x03, 0x03, 
+	0x04, 0x03, 0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 
+	0x06, 0x09, 0x08, 0x11, 0x0d, 0x09, 0x04, 0x04, 0x04, 
+	0x00, 0x03, 0x03, 0x03, 0x09, 0x0c, 0x03, 0x02, 0x03, 
+	0x0a, 0x0c, 0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 
+	0x03, 0x15, 0x0f, 0x14, 0x0f, 0x0f, 0x06, 0x03, 0x04, 
+	0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x11, 0x0f, 0x04, 0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x09, 0x0c, 0x03, 0x03, 0x06, 0x0e, 0x09, 0x04, 
+	0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x15, 0x0f, 
+	0x14, 0x0f, 0x0f, 0x06, 0x03, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x0c, 0x09, 0x03, 0x15, 0x0b, 0x0b, 0x15, 
+	0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 
+	0x09, 0x0f, 0x0f, 0x14, 0x0f, 0x0f, 0x0c, 0x03, 0x04, 
+	0x05, 0x00, 0x03, 0x03, 0x03, 0x08, 0x0f, 0x0f, 0x14, 
+	0x0f, 0x0f, 0x09, 0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 
+	0x03, 0x09, 0x0f, 0x0f, 0x0f, 0x14, 0x0f, 0x0a, 0x04, 
+	0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x09, 0x0c, 0x03, 0x04, 0x04, 0x04, 0x00, 0x03, 
+	0x03, 0x03, 0x0b, 0x0c, 0x0f, 0x14, 0x0f, 0x15, 0x0b, 
+	0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 
+	0x05, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 
+	0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 
+	0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x0c, 0x09, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x09, 0x06, 0x03, 0x11, 0x14, 0x04, 0x04, 
+	0x05, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x04, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 
+	0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x03, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 
+	0x04, 0x09, 0x09, 0x09, 0x0c, 0x14, 0x06, 0x04, 0x05, 
+	0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x15, 0x0d, 
+	0x09, 0x0c, 0x13, 0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x03, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 
+	0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x0c, 0x0d, 0x0d, 
+	0x0c, 0x02, 0x04, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 
+	0x04, 0x04, 0x04, 0x06, 0x0c, 0x0d, 0x0c, 0x06, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x00, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x18, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 
+	0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 
+	0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 
+	0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 
+	0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 
+	0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x01, 0x17, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 
+	0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 
+	0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 
+	0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 
+	0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 
+	0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 
+	0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 
+	0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 
+	0x03, 0x02, 0x03, 0x03, 0x03, 0x04, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 
+	0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 
+	0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 
+	0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 
+	0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 
+	0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x05, 0x02, 0x06, 
+	0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 
+	0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 
+	0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x05, 0x02, 0x06, 
+	0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 
+	0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x05, 0x02, 0x06, 0x02, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x06, 0x0b, 0x02, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x10, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 
+	0x06, 0x0a, 0x0d, 0x11, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x0a, 0x0d, 0x0e, 
+	0x0d, 0x0d, 0x0d, 0x12, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x11, 0x0e, 0x0d, 0x0d, 0x0b, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x0a, 0x0d, 
+	0x0e, 0x0d, 0x0d, 0x0d, 0x07, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x11, 0x0d, 0x0e, 0x0d, 0x0d, 0x0d, 
+	0x06, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x0b, 0x07, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x0a, 0x0b, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x02, 0x11, 0x13, 0x0b, 0x03, 
+	0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 
+	0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x07, 0x0f, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 
+	0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x13, 0x0b, 
+	0x06, 0x06, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x08, 0x13, 0x12, 0x08, 0x08, 0x0e, 0x0d, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x07, 
+	0x0f, 0x12, 0x0f, 0x10, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x12, 0x13, 0x12, 0x08, 0x12, 0x13, 
+	0x08, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 
+	0x13, 0x12, 0x08, 0x12, 0x13, 0x08, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 
+	0x0b, 0x13, 0x08, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x12, 
+	0x13, 0x0b, 0x06, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 
+	0x02, 0x11, 0x15, 0x0b, 0x03, 0x04, 0x04, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x11, 
+	0x11, 0x11, 0x07, 0x06, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x0b, 0x07, 0x14, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 
+	0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 
+	0x06, 0x0b, 0x12, 0x0e, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x06, 
+	0x06, 0x06, 0x06, 0x08, 0x0d, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x0b, 0x07, 0x14, 0x06, 0x0f, 0x10, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 
+	0x0e, 0x06, 0x06, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x12, 0x0d, 0x06, 0x06, 0x02, 
+	0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 
+	0x06, 0x0b, 0x0b, 0x0b, 0x0b, 0x13, 0x0f, 0x08, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x0b, 0x12, 0x0f, 0x13, 0x06, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 
+	0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x11, 0x15, 0x0b, 
+	0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x06, 0x06, 0x0b, 0x08, 0x0d, 0x08, 0x15, 0x0f, 0x0e, 
+	0x06, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 
+	0x12, 0x0f, 0x0f, 0x14, 0x08, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x12, 0x13, 0x13, 0x0f, 0x15, 
+	0x11, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x06, 0x12, 0x0f, 0x0f, 0x0e, 0x0e, 0x09, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x08, 0x0d, 0x10, 0x13, 
+	0x14, 0x13, 0x0b, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x11, 0x13, 0x0f, 0x14, 0x0f, 0x13, 0x0b, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x08, 0x0f, 0x0f, 
+	0x0f, 0x0f, 0x15, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x08, 0x0d, 0x06, 0x06, 0x06, 0x0c, 0x09, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x08, 0x0d, 
+	0x06, 0x06, 0x06, 0x09, 0x0c, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x15, 0x10, 0x06, 0x06, 0x06, 0x02, 
+	0x15, 0x0b, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x08, 
+	0x13, 0x0b, 0x06, 0x0b, 0x0e, 0x09, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x08, 0x0d, 0x06, 0x06, 0x06, 
+	0x09, 0x0c, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x08, 0x0f, 0x0f, 0x0f, 0x14, 0x0f, 0x09, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x0d, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x08, 
+	0x0d, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 
+	0x07, 0x0f, 0x06, 0x0f, 0x10, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x12, 0x13, 0x12, 0x08, 0x08, 
+	0x13, 0x08, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x12, 0x0e, 0x06, 0x06, 0x02, 0x0d, 0x08, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x11, 
+	0x13, 0x0f, 0x0f, 0x08, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x10, 0x12, 0x12, 0x12, 0x12, 0x08, 0x12, 0x08, 
+	0x08, 0x07, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 
+	0x12, 0x0f, 0x0f, 0x13, 0x06, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 
+	0x06, 0x02, 0x11, 0x15, 0x0b, 0x03, 0x04, 0x04, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x12, 
+	0x0f, 0x13, 0x09, 0x10, 0x13, 0x09, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x06, 0x09, 0x0f, 0x08, 0x07, 0x09, 
+	0x13, 0x0a, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 
+	0x12, 0x0f, 0x0d, 0x06, 0x0c, 0x0f, 0x0b, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x09, 0x15, 0x08, 0x07, 
+	0x16, 0x0f, 0x08, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x12, 0x13, 0x15, 0x12, 0x10, 0x0d, 0x0c, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x12, 0x15, 0x07, 
+	0x07, 0x10, 0x16, 0x07, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x11, 0x09, 0x14, 0x07, 0x10, 0x11, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x12, 0x0d, 
+	0x06, 0x06, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x12, 0x0e, 0x06, 0x06, 0x02, 0x12, 
+	0x0d, 0x03, 0x03, 0x03, 0x00, 0x06, 0x06, 0x06, 0x0f, 
+	0x07, 0x06, 0x06, 0x02, 0x02, 0x0f, 0x11, 0x03, 0x03, 
+	0x00, 0x06, 0x06, 0x06, 0x06, 0x13, 0x0e, 0x06, 0x0d, 
+	0x0e, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 
+	0x12, 0x0d, 0x06, 0x06, 0x02, 0x12, 0x0d, 0x03, 0x03, 
+	0x03, 0x00, 0x06, 0x06, 0x06, 0x11, 0x07, 0x07, 0x07, 
+	0x12, 0x0f, 0x07, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x06, 0x06, 0x06, 0x12, 0x0d, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x07, 0x15, 0x12, 0x03, 0x03, 0x03, 
+	0x00, 0x06, 0x06, 0x06, 0x11, 0x16, 0x0f, 0x12, 0x0f, 
+	0x12, 0x06, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 
+	0x0a, 0x0d, 0x0e, 0x0d, 0x0e, 0x15, 0x08, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x12, 0x0d, 0x06, 0x06, 
+	0x06, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x06, 0x06, 0x06, 0x11, 0x0e, 0x0f, 0x0f, 0x14, 0x08, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0c, 0x0f, 
+	0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x06, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x06, 0x06, 0x12, 0x0f, 0x0f, 0x14, 
+	0x0e, 0x06, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x11, 0x15, 
+	0x0b, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x02, 0x06, 0x06, 0x08, 0x13, 0x06, 0x02, 0x02, 
+	0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x12, 0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x13, 0x06, 0x02, 
+	0x02, 0x13, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x12, 0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x15, 0x11, 
+	0x02, 0x02, 0x07, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x06, 0x06, 0x11, 0x15, 0x13, 0x08, 0x06, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x07, 
+	0x0f, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x06, 0x12, 0x13, 0x06, 0x02, 0x02, 0x0d, 
+	0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x11, 
+	0x14, 0x0b, 0x06, 0x02, 0x13, 0x0a, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x13, 0x09, 0x06, 0x15, 0x11, 
+	0x0b, 0x0f, 0x06, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x0b, 0x15, 0x15, 0x15, 0x06, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x11, 0x14, 0x0b, 0x06, 
+	0x02, 0x13, 0x09, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x07, 0x14, 0x07, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x06, 0x06, 0x12, 
+	0x13, 0x12, 0x08, 0x08, 0x08, 0x0b, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x0a, 0x0f, 
+	0x07, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x08, 0x15, 0x0d, 0x0d, 0x0d, 0x15, 0x09, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x12, 0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x06, 0x06, 0x06, 
+	0x0c, 0x14, 0x0f, 0x0f, 0x08, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x0c, 0x14, 0x0f, 0x14, 0x0f, 
+	0x13, 0x06, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x12, 0x0f, 0x0f, 0x0f, 0x0c, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x11, 0x15, 0x0b, 0x03, 0x04, 0x04, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x06, 
+	0x08, 0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x02, 0x06, 0x08, 0x0d, 0x06, 0x02, 
+	0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 
+	0x06, 0x08, 0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x08, 0x0d, 0x02, 
+	0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x02, 0x06, 0x08, 0x0d, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x02, 0x0b, 
+	0x08, 0x13, 0x15, 0x12, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x02, 0x06, 0x02, 0x10, 0x0f, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x10, 
+	0x0f, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x02, 0x06, 0x02, 0x0e, 0x16, 0x02, 0x0a, 
+	0x15, 0x06, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 
+	0x0d, 0x08, 0x02, 0x0f, 0x10, 0x10, 0x0f, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x02, 0x06, 0x02, 0x02, 0x08, 0x0f, 
+	0x08, 0x03, 0x03, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 
+	0x06, 0x02, 0x13, 0x12, 0x02, 0x0a, 0x15, 0x06, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x02, 0x02, 0x0a, 
+	0x0f, 0x07, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x06, 0x08, 0x15, 0x0d, 0x0d, 0x0d, 
+	0x15, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x02, 
+	0x02, 0x06, 0x02, 0x0f, 0x09, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x02, 0x08, 0x0d, 0x06, 0x02, 
+	0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 
+	0x06, 0x02, 0x02, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x08, 0x0d, 0x06, 
+	0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x06, 0x02, 0x06, 0x0c, 0x0f, 0x0f, 
+	0x08, 0x03, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x02, 
+	0x06, 0x0c, 0x0f, 0x0f, 0x13, 0x06, 0x03, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x02, 0x06, 0x02, 0x08, 0x14, 0x0f, 
+	0x0c, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x06, 0x02, 0x02, 0x06, 0x11, 0x02, 0x11, 
+	0x13, 0x0b, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x08, 0x0d, 0x02, 0x02, 
+	0x02, 0x08, 0x0d, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x02, 0x08, 0x0d, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x03, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x08, 0x13, 0x02, 
+	0x02, 0x02, 0x0e, 0x08, 0x03, 0x04, 0x04, 0x00, 0x02, 
+	0x02, 0x02, 0x08, 0x0d, 0x02, 0x02, 0x02, 0x0e, 0x08, 
+	0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x08, 0x0d, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0a, 0x15, 
+	0x0a, 0x04, 0x03, 0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x10, 0x14, 0x02, 0x02, 0x06, 0x06, 0x03, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x02, 0x10, 0x14, 0x02, 0x02, 0x02, 
+	0x0e, 0x08, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x10, 0x0f, 0x06, 0x0e, 0x08, 0x03, 0x03, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x0d, 0x16, 0x11, 0x0f, 
+	0x09, 0x07, 0x15, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x11, 0x15, 0x12, 0x15, 0x0b, 0x03, 0x03, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 0x0a, 0x15, 
+	0x02, 0x0e, 0x12, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 
+	0x02, 0x02, 0x02, 0x0a, 0x0f, 0x0a, 0x02, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x08, 0x0d, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0f, 
+	0x10, 0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x02, 0x08, 0x0d, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x03, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x0d, 0x08, 0x03, 0x04, 0x04, 0x00, 0x02, 
+	0x02, 0x02, 0x08, 0x0d, 0x02, 0x02, 0x02, 0x0d, 0x08, 
+	0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x0c, 0x0f, 0x08, 0x03, 0x03, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0c, 0x0e, 
+	0x06, 0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x08, 0x0f, 0x0c, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x0b, 0x0d, 0x0e, 0x10, 0x07, 0x15, 0x0b, 0x04, 0x04, 
+	0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 
+	0x03, 0x08, 0x0d, 0x02, 0x03, 0x03, 0x08, 0x0d, 0x04, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x0a, 0x15, 0x0a, 
+	0x10, 0x0a, 0x0f, 0x07, 0x04, 0x04, 0x04, 0x00, 0x02, 
+	0x02, 0x03, 0x08, 0x0f, 0x0c, 0x02, 0x16, 0x0f, 0x0b, 
+	0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x0a, 0x14, 
+	0x0a, 0x10, 0x0c, 0x14, 0x09, 0x03, 0x04, 0x04, 0x00, 
+	0x02, 0x02, 0x03, 0x08, 0x0d, 0x02, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x07, 
+	0x12, 0x10, 0x10, 0x11, 0x13, 0x09, 0x04, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x03, 0x02, 0x0b, 0x0f, 0x07, 0x11, 
+	0x0e, 0x0d, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 
+	0x11, 0x0f, 0x07, 0x0a, 0x13, 0x0f, 0x08, 0x04, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x03, 0x02, 0x02, 0x13, 0x0c, 
+	0x0f, 0x06, 0x03, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x03, 0x07, 0x15, 0x15, 0x0d, 0x0f, 0x13, 0x08, 0x03, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x06, 0x15, 0x12, 
+	0x02, 0x12, 0x15, 0x02, 0x03, 0x04, 0x04, 0x00, 0x02, 
+	0x02, 0x03, 0x02, 0x06, 0x15, 0x0e, 0x0f, 0x06, 0x03, 
+	0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x07, 0x0f, 
+	0x12, 0x10, 0x11, 0x11, 0x06, 0x04, 0x04, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x03, 0x08, 0x13, 0x10, 0x10, 
+	0x11, 0x0e, 0x08, 0x04, 0x04, 0x04, 0x00, 0x02, 0x03, 
+	0x02, 0x02, 0x03, 0x02, 0x0f, 0x10, 0x03, 0x03, 0x04, 
+	0x04, 0x04, 0x00, 0x02, 0x03, 0x02, 0x08, 0x13, 0x10, 
+	0x11, 0x10, 0x0e, 0x08, 0x04, 0x04, 0x04, 0x00, 0x02, 
+	0x02, 0x03, 0x02, 0x02, 0x03, 0x02, 0x03, 0x0e, 0x08, 
+	0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x08, 0x13, 
+	0x11, 0x10, 0x11, 0x0e, 0x08, 0x04, 0x04, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x03, 0x02, 0x03, 0x02, 0x02, 
+	0x16, 0x08, 0x03, 0x04, 0x04, 0x04, 0x00, 0x02, 0x03, 
+	0x02, 0x02, 0x03, 0x02, 0x06, 0x03, 0x03, 0x03, 0x04, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x02, 0x08, 0x0c, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x03, 0x02, 0x09, 0x0f, 0x13, 0x0d, 
+	0x0e, 0x15, 0x11, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x09, 0x0c, 0x03, 
+	0x02, 0x03, 0x0a, 0x0c, 0x03, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x08, 0x15, 0x0f, 0x15, 0x08, 0x04, 
+	0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x08, 0x13, 
+	0x15, 0x0f, 0x15, 0x0b, 0x04, 0x03, 0x04, 0x05, 0x00, 
+	0x03, 0x03, 0x03, 0x03, 0x08, 0x0f, 0x0f, 0x0c, 0x0d, 
+	0x09, 0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 0x09, 
+	0x0c, 0x03, 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x05, 
+	0x00, 0x03, 0x03, 0x03, 0x0b, 0x13, 0x0f, 0x0f, 0x14, 
+	0x0d, 0x02, 0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x12, 0x0f, 0x0f, 0x13, 0x06, 0x03, 0x04, 
+	0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x0c, 0x0f, 0x15, 
+	0x08, 0x0c, 0x09, 0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x10, 0x0f, 0x16, 0x03, 0x04, 0x03, 
+	0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x15, 0x0e, 
+	0x03, 0x12, 0x0f, 0x0b, 0x04, 0x04, 0x04, 0x00, 0x03, 
+	0x03, 0x03, 0x09, 0x0e, 0x03, 0x03, 0x03, 0x0e, 0x0a, 
+	0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x10, 0x13, 0x16, 0x03, 0x04, 0x03, 0x04, 0x05, 0x00, 
+	0x03, 0x03, 0x03, 0x09, 0x0f, 0x0f, 0x14, 0x0f, 0x0f, 
+	0x09, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x03, 0x03, 
+	0x03, 0x09, 0x0f, 0x0f, 0x0f, 0x14, 0x0f, 0x09, 0x04, 
+	0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x15, 0x0b, 0x03, 0x04, 0x03, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x11, 0x15, 0x0f, 0x0f, 0x0f, 0x15, 0x0b, 
+	0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x0b, 0x0f, 0x09, 0x04, 0x04, 0x04, 0x00, 
+	0x03, 0x03, 0x03, 0x11, 0x15, 0x0f, 0x0f, 0x14, 0x15, 
+	0x0b, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x0b, 0x03, 0x04, 
+	0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x04, 0x03, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x11, 0x03, 0x03, 0x03, 0x03, 0x04, 
+	0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 
+	0x03, 0x02, 0x09, 0x0c, 0x06, 0x02, 0x02, 0x03, 0x04, 
+	0x04, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x04, 0x05, 0x00, 
+	0x03, 0x03, 0x03, 0x09, 0x0d, 0x02, 0x11, 0x02, 0x03, 
+	0x04, 0x04, 0x05, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x0d, 0x09, 0x04, 0x04, 0x05, 
+	0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x04, 0x05, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x04, 0x03, 0x03, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x04, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x06, 0x0f, 0x0b, 0x03, 
+	0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x04, 0x05, 0x00, 
+	0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x03, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x09, 
+	0x0d, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 
+	0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x0c, 0x09, 0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 
+	0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x06, 
+	0x09, 0x0d, 0x0e, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 
+	0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 
+	0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x03, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x03, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x01, 0x04, 0x04, 0x11, 0x09, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x09, 0x11, 0x05, 0x05, 
+	0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x05, 0x04, 0x17, 0x00, 0x01, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x01, 0x04, 0x04, 0x11, 0x0d, 0x0d, 0x11, 0x04, 
+	0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 
+	0x17, 0x00, 0x00, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 
+	0x17, 0x00, 0x00, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x00, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x18, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 
+	0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 
+	0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 
+	0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 
+	0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 
+	0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 
+	0x05, 0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x01, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00 
+};
+// *************************************************************************
+//									 LANDSCAPE
+// *************************************************************************
+
+// Panel
+
+unsigned char item_toolbar_colors[] = { 
+	0x04, 0x02, 0x04, 
+	0x0c, 0x02, 0x04, 
+	0x24, 0x06, 0x04, 
+	0x84, 0x16, 0x14, 
+	0x9c, 0x1a, 0x1c, 
+	0x74, 0x16, 0x14, 
+	0x1c, 0x06, 0x04, 
+	0x5c, 0x0e, 0x0c, 
+	0x4c, 0x0e, 0x0c, 
+	0x44, 0x0a, 0x0c, 
+	0x64, 0x12, 0x14, 
+	0x8c, 0x1a, 0x1c, 
+	0xc4, 0x22, 0x24, 
+	0xb4, 0x1e, 0x1c, 
+	0x0c, 0x06, 0x04, 
+	0xa4, 0x1e, 0x1c, 
+	0x34, 0x0a, 0x0c, 
+	0x14, 0x16, 0x14, 
+	0x64, 0x66, 0x64, 
+	0x1c, 0x16, 0x1c, 
+	0x1c, 0x1a, 0x1c, 
+	0x3c, 0x3e, 0x3c, 
+	0x34, 0x36, 0x34, 
+	0x34, 0x32, 0x34, 
+	0x6c, 0x6a, 0x6c, 
+	0xb4, 0xb2, 0xb4, 
+	0x4c, 0x4e, 0x4c, 
+	0x94, 0x92, 0x94, 
+	0x94, 0x96, 0x94, 
+	0x7c, 0x7e, 0x7c, 
+	0x9c, 0x9e, 0x9c, 
+	0x0c, 0x0a, 0x0c, 
+	0x44, 0x46, 0x44, 
+	0x5c, 0x5a, 0x5c, 
+	0x74, 0x76, 0x74, 
+	0xc4, 0xc2, 0xc4, 
+	0x84, 0x82, 0x84, 
+	0x9c, 0x9a, 0x9c, 
+	0x74, 0x72, 0x74, 
+	0x24, 0x26, 0x24, 
+	0xa4, 0xa6, 0xa4, 
+	0x3c, 0x3a, 0x3c, 
+	0x8c, 0x8e, 0x8c, 
+	0x2c, 0x7e, 0xb4, 
+	0xbc, 0xbe, 0xbc, 
+	0x6c, 0x6e, 0x6c, 
+	0x1c, 0x1e, 0x1c, 
+	0x2c, 0x5e, 0x7c, 
+	0xac, 0xaa, 0xac, 
+	0x5c, 0x5e, 0x5c, 
+	0xa4, 0xa2, 0xa4, 
+	0xd4, 0xd6, 0xd4, 
+	0xac, 0xae, 0xac, 
+	0xec, 0xee, 0xec, 
+	0xe4, 0xe6, 0xe4, 
+	0xfc, 0xfa, 0xfc, 
+	0x1c, 0x0a, 0x0c, 
+	0x2c, 0x0e, 0x0c, 
+	0x24, 0x0a, 0x0c, 
+	0x14, 0x06, 0x04, 
+	0x34, 0x0e, 0x0c, 
+	0xcc, 0xce, 0xcc, 
+	0xf4, 0xf2, 0xf4, 
+	0x0c, 0x0a, 0x04, 
+	0x24, 0x1a, 0x0c, 
+	0x2c, 0x1e, 0x14, 
+	0x24, 0x1e, 0x0c, 
+	0x24, 0x1e, 0x14, 
+	0x1c, 0x16, 0x0c, 
+	0x14, 0x0e, 0x04, 
+	0x04, 0x06, 0x04, 
+	0x14, 0x12, 0x0c, 
+	0x5c, 0x1a, 0x1c, 
+	0x94, 0x26, 0x24, 
+	0xb4, 0x2e, 0x2c, 
+	0xd4, 0x3a, 0x3c, 
+	0xcc, 0x36, 0x34, 
+	0xa4, 0x2e, 0x2c, 
+	0x54, 0x16, 0x14, 
+	0x4c, 0x16, 0x14, 
+	0x7c, 0x22, 0x24, 
+	0x9c, 0x2a, 0x2c, 
+	0xbc, 0x36, 0x34, 
+	0xb4, 0x32, 0x34, 
+	0xac, 0x2e, 0x2c, 
+	0x2c, 0x0a, 0x0c, 
+	0xa4, 0x2a, 0x2c, 
+	0x6c, 0x1e, 0x1c, 
+	0x64, 0x1e, 0x1c, 
+	0x94, 0x2a, 0x2c, 
+	0x34, 0x22, 0x24, 
+	0x64, 0x4a, 0x24, 
+	0xc4, 0x96, 0x4c, 
+	0xd4, 0xa2, 0x54, 
+	0xcc, 0x9e, 0x54, 
+	0x84, 0x66, 0x34, 
+	0x14, 0x0e, 0x0c, 
+	0xec, 0xb2, 0x5c, 
+	0xdc, 0xaa, 0x5c, 
+	0x94, 0x72, 0x3c, 
+	0xe4, 0xb2, 0x5c, 
+	0x4c, 0x3a, 0x1c, 
+	0xc4, 0x36, 0x34, 
+	0xbc, 0x32, 0x34, 
+	0xc4, 0x32, 0x34, 
+	0x8c, 0x26, 0x24, 
+	0x44, 0x12, 0x14, 
+	0x74, 0x1e, 0x1c, 
+	0x5c, 0x16, 0x14, 
+	0xb4, 0x86, 0x44, 
+	0xfc, 0xc6, 0x6c, 
+	0xf4, 0xbe, 0x64, 
+	0xf4, 0xba, 0x64, 
+	0xfc, 0xbe, 0x64, 
+	0xec, 0xb6, 0x64, 
+	0x2c, 0x22, 0x14, 
+	0xfc, 0xce, 0x6c, 
+	0xfc, 0xc2, 0x64, 
+	0xcc, 0x9a, 0x54, 
+	0xdc, 0xa6, 0x54, 
+	0xfc, 0xd2, 0x6c, 
+	0x5c, 0x46, 0x24, 
+	0xcc, 0x3a, 0x3c, 
+	0x84, 0x22, 0x24, 
+	0x84, 0x26, 0x24, 
+	0xdc, 0xde, 0xdc, 
+	0xe4, 0xe2, 0xe4, 
+	0x5c, 0x4a, 0x2c, 
+	0xec, 0xb6, 0x5c, 
+	0x9c, 0x7a, 0x3c, 
+	0xfc, 0xc6, 0x64, 
+	0x34, 0x26, 0x14, 
+	0x4c, 0x12, 0x14, 
+	0x64, 0x1a, 0x1c, 
+	0x54, 0x3e, 0x24, 
+	0xf4, 0xb6, 0x64, 
+	0x6c, 0x56, 0x2c, 
+	0x3c, 0x2a, 0x14, 
+	0x44, 0x32, 0x1c, 
+	0xac, 0x32, 0x34, 
+	0x54, 0x1a, 0x1c, 
+	0x3c, 0x12, 0x14, 
+	0xe4, 0xae, 0x5c, 
+	0x6c, 0x52, 0x2c, 
+	0x74, 0x5a, 0x34, 
+	0xc4, 0x9a, 0x54, 
+	0x7c, 0x62, 0x34, 
+	0x84, 0x62, 0x34, 
+	0xbc, 0xba, 0xbc, 
+	0x7c, 0x5e, 0x34, 
+	0x8c, 0x66, 0x34, 
+	0x9c, 0x76, 0x3c, 
+	0x94, 0x6e, 0x3c, 
+	0x8c, 0x6a, 0x3c, 
+	0x74, 0x22, 0x24, 
+	0xbc, 0x8e, 0x4c, 
+	0xb4, 0x8a, 0x4c, 
+	0xb4, 0x8e, 0x4c, 
+	0x44, 0x36, 0x1c, 
+	0x7c, 0x5a, 0x34, 
+	0x8c, 0x6a, 0x34, 
+	0x74, 0x56, 0x2c, 
+	0x5c, 0x4a, 0x24, 
+	0xbc, 0x92, 0x4c, 
+	0xe4, 0xaa, 0x5c, 
+	0x64, 0x4e, 0x2c, 
+	0x54, 0x3e, 0x1c, 
+	0x8c, 0x6e, 0x3c, 
+	0x0c, 0x06, 0x0c, 
+	0xa4, 0x7e, 0x44, 
+	0x94, 0x76, 0x3c, 
+	0x9c, 0x2e, 0x34, 
+	0x8c, 0x2a, 0x2c, 
+	0x8c, 0x8a, 0x8c, 
+	0x54, 0x42, 0x24, 
+	0x4c, 0x3e, 0x1c, 
+	0xd4, 0xa6, 0x54, 
+	0x1c, 0x1a, 0x0c, 
+	0x2c, 0x2e, 0x2c, 
+	0xac, 0x82, 0x44
+
+};
+unsigned char item_toolbar[] = { 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x02, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 
+	0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, 0x05, 
+	0x03, 0x04, 0x07, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x06, 0x07, 0x03, 0x03, 0x03, 0x05, 0x09, 
+	0x00, 0x0a, 0x03, 0x04, 0x03, 0x00, 0x00, 0x00, 0x07, 
+	0x03, 0x03, 0x04, 0x02, 0x02, 0x04, 0x03, 0x04, 0x03, 
+	0x04, 0x0b, 0x03, 0x0b, 0x07, 0x02, 0x03, 0x04, 0x03, 
+	0x04, 0x03, 0x03, 0x04, 0x03, 0x04, 0x0a, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x0c, 
+	0x0d, 0x0c, 0x0d, 0x0c, 0x0d, 0x0c, 0x0d, 0x0e, 0x00, 
+	0x00, 0x07, 0x0c, 0x0d, 0x0c, 0x0c, 0x0d, 0x0c, 0x0c, 
+	0x0f, 0x02, 0x00, 0x00, 0x00, 0x01, 0x05, 0x0c, 0x0c, 
+	0x0c, 0x0c, 0x0c, 0x0c, 0x04, 0x00, 0x03, 0x0c, 0x0c, 
+	0x0d, 0x00, 0x00, 0x10, 0x0c, 0x0c, 0x0c, 0x07, 0x00, 
+	0x02, 0x0c, 0x0d, 0x0c, 0x0c, 0x0d, 0x0c, 0x0c, 0x0d, 
+	0x07, 0x10, 0x0c, 0x0d, 0x0c, 0x0d, 0x0c, 0x0c, 0x0c, 
+	0x0d, 0x0c, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x10, 0x0c, 0x0c, 0x04, 0x10, 0x09, 
+	0x0d, 0x0c, 0x0d, 0x07, 0x00, 0x05, 0x0d, 0x0c, 0x0c, 
+	0x0d, 0x03, 0x0d, 0x0d, 0x0c, 0x0c, 0x0d, 0x01, 0x00, 
+	0x00, 0x04, 0x0d, 0x0c, 0x0c, 0x0d, 0x04, 0x03, 0x03, 
+	0x03, 0x00, 0x04, 0x0d, 0x0c, 0x0c, 0x00, 0x01, 0x0d, 
+	0x0d, 0x0c, 0x03, 0x00, 0x00, 0x10, 0x0c, 0x0c, 0x0c, 
+	0x0a, 0x07, 0x07, 0x07, 0x07, 0x10, 0x01, 0x07, 0x07, 
+	0x07, 0x0c, 0x0c, 0x0d, 0x05, 0x07, 0x07, 0x09, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 
+	0x0d, 0x0c, 0x03, 0x00, 0x00, 0x03, 0x0c, 0x0c, 0x07, 
+	0x10, 0x0c, 0x0c, 0x0c, 0x03, 0x01, 0x00, 0x00, 0x09, 
+	0x0c, 0x0d, 0x0c, 0x05, 0x00, 0x07, 0x0d, 0x0c, 0x0c, 
+	0x05, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0c, 
+	0x0c, 0x0d, 0x00, 0x05, 0x0c, 0x0c, 0x0d, 0x01, 0x00, 
+	0x00, 0x10, 0x0d, 0x0c, 0x0c, 0x10, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x0c, 0x0c, 
+	0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x11, 0x11, 0x11, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x10, 0x0c, 0x0c, 0x03, 0x00, 
+	0x02, 0x0c, 0x0c, 0x0d, 0x09, 0x0a, 0x0c, 0x0d, 0x0c, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0c, 0x0c, 0x0d, 
+	0x00, 0x04, 0x0c, 0x0c, 0x0f, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x03, 0x0c, 0x0c, 0x0d, 0x07, 0x0c, 
+	0x0c, 0x0d, 0x02, 0x00, 0x00, 0x00, 0x10, 0x0c, 0x0c, 
+	0x0d, 0x04, 0x04, 0x03, 0x0b, 0x08, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x0c, 0x0c, 0x0c, 0x02, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x12, 0x12, 0x13, 0x11, 0x14, 0x15, 0x16, 
+	0x17, 0x11, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x0c, 0x0d, 0x0a, 0x0f, 0x0c, 0x0c, 0x0d, 0x04, 
+	0x00, 0x03, 0x0c, 0x0c, 0x03, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x07, 0x0d, 0x0c, 0x0c, 0x00, 0x0c, 0x0c, 0x0d, 
+	0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 
+	0x0c, 0x0c, 0x03, 0x0f, 0x0c, 0x0d, 0x04, 0x00, 0x00, 
+	0x00, 0x00, 0x02, 0x0c, 0x0d, 0x0c, 0x0c, 0x0c, 0x0d, 
+	0x0c, 0x07, 0x00, 0x00, 0x00, 0x00, 0x02, 0x0d, 0x0c, 
+	0x0c, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x12, 0x18, 0x12, 0x19, 0x18, 
+	0x1a, 0x12, 0x1b, 0x1c, 0x1d, 0x17, 0x16, 0x17, 0x12, 
+	0x18, 0x12, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x0c, 0x0c, 0x07, 
+	0x05, 0x0d, 0x0d, 0x05, 0x01, 0x00, 0x03, 0x0c, 0x0c, 
+	0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0c, 0x0d, 
+	0x0d, 0x00, 0x0d, 0x0c, 0x0c, 0x07, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x03, 0x0c, 0x0d, 0x04, 0x09, 
+	0x0c, 0x0c, 0x0c, 0x09, 0x00, 0x00, 0x00, 0x07, 0x0c, 
+	0x0c, 0x0c, 0x0a, 0x07, 0x07, 0x07, 0x02, 0x00, 0x00, 
+	0x00, 0x00, 0x10, 0x0c, 0x0c, 0x0d, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 
+	0x19, 0x1e, 0x1e, 0x1d, 0x1f, 0x20, 0x21, 0x22, 0x23, 
+	0x19, 0x24, 0x12, 0x18, 0x1e, 0x1e, 0x19, 0x19, 0x18, 
+	0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x07, 0x0c, 0x0d, 0x07, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x07, 0x0c, 0x0d, 0x0c, 0x02, 0x00, 0x00, 
+	0x00, 0x01, 0x0d, 0x0c, 0x0c, 0x03, 0x00, 0x04, 0x0d, 
+	0x0c, 0x0d, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x04, 0x0c, 0x0c, 0x03, 0x00, 0x03, 0x0c, 0x0d, 0x0d, 
+	0x01, 0x00, 0x00, 0x07, 0x0c, 0x0d, 0x0c, 0x10, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x0c, 
+	0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x25, 0x19, 0x1e, 0x26, 0x26, 0x27, 
+	0x00, 0x17, 0x17, 0x16, 0x12, 0x1e, 0x19, 0x28, 0x1b, 
+	0x29, 0x2a, 0x1e, 0x25, 0x19, 0x1e, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x0d, 0x0c, 
+	0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x0c, 
+	0x0c, 0x0c, 0x0d, 0x07, 0x10, 0x08, 0x0d, 0x0c, 0x0d, 
+	0x0c, 0x02, 0x00, 0x07, 0x0c, 0x0c, 0x0d, 0x0f, 0x08, 
+	0x09, 0x02, 0x07, 0x02, 0x00, 0x0c, 0x0c, 0x0c, 0x03, 
+	0x00, 0x01, 0x0d, 0x0c, 0x0c, 0x03, 0x00, 0x00, 0x07, 
+	0x0c, 0x0c, 0x0d, 0x07, 0x02, 0x10, 0x10, 0x07, 0x00, 
+	0x00, 0x00, 0x00, 0x07, 0x0c, 0x0c, 0x0d, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 
+	0x1e, 0x28, 0x1b, 0x1c, 0x00, 0x00, 0x16, 0x2b, 0x17, 
+	0x17, 0x2c, 0x1d, 0x19, 0x2a, 0x00, 0x28, 0x28, 0x2a, 
+	0x1e, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x07, 0x0c, 0x0c, 0x07, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x09, 0x0c, 0x0c, 0x0d, 0x0c, 
+	0x0d, 0x0c, 0x0d, 0x0c, 0x0c, 0x08, 0x00, 0x00, 0x00, 
+	0x0a, 0x0c, 0x0c, 0x0c, 0x0d, 0x0c, 0x0c, 0x0c, 0x10, 
+	0x00, 0x0d, 0x0c, 0x0c, 0x03, 0x00, 0x00, 0x07, 0x0c, 
+	0x0d, 0x0c, 0x07, 0x00, 0x05, 0x0d, 0x0c, 0x0c, 0x0c, 
+	0x0c, 0x0c, 0x0d, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x07, 
+	0x0c, 0x0d, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x25, 0x25, 0x19, 
+	0x2d, 0x2e, 0x17, 0x2f, 0x16, 0x17, 0x30, 0x31, 0x19, 
+	0x2a, 0x26, 0x19, 0x1e, 0x2a, 0x1b, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0c, 
+	0x0d, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x02, 0x05, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x03, 
+	0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x04, 0x0c, 
+	0x0c, 0x0c, 0x0c, 0x0d, 0x01, 0x00, 0x0c, 0x0d, 0x0c, 
+	0x03, 0x00, 0x00, 0x00, 0x0d, 0x0d, 0x0c, 0x0d, 0x02, 
+	0x03, 0x0c, 0x0d, 0x0c, 0x0d, 0x0c, 0x0d, 0x0c, 0x04, 
+	0x00, 0x00, 0x00, 0x00, 0x03, 0x0d, 0x0c, 0x0d, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x17, 0x1b, 0x1e, 0x25, 0x32, 0x15, 0x17, 
+	0x16, 0x1e, 0x33, 0x34, 0x19, 0x26, 0x19, 0x1e, 0x2a, 
+	0x2a, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x10, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 0x02, 0x10, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2d, 
+	0x2a, 0x1b, 0x22, 0x20, 0x16, 0x1e, 0x35, 0x36, 0x33, 
+	0x1d, 0x1d, 0x25, 0x2a, 0x1b, 0x17, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x14, 0x1b, 0x2a, 0x2a, 0x2a, 
+	0x28, 0x33, 0x37, 0x35, 0x2c, 0x1c, 0x2a, 0x1b, 0x2a, 
+	0x2d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x38, 
+	0x39, 0x39, 0x39, 0x3a, 0x38, 0x38, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x06, 
+	0x3a, 0x3c, 0x39, 0x3c, 0x3a, 0x06, 0x38, 0x00, 0x00, 
+	0x00, 0x06, 0x38, 0x02, 0x38, 0x3a, 0x38, 0x3b, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x3a, 0x38, 0x38, 0x02, 0x38, 
+	0x06, 0x0e, 0x00, 0x00, 0x01, 0x06, 0x3a, 0x38, 0x38, 
+	0x06, 0x3a, 0x38, 0x06, 0x01, 0x00, 0x00, 0x00, 0x3b, 
+	0x3a, 0x06, 0x38, 0x06, 0x3a, 0x06, 0x38, 0x02, 0x00, 
+	0x00, 0x00, 0x3b, 0x3a, 0x06, 0x3a, 0x38, 0x02, 0x38, 
+	0x38, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x06, 0x38, 0x02, 
+	0x38, 0x2d, 0x2a, 0x19, 0x3d, 0x3e, 0x3e, 0x37, 0x37, 
+	0x36, 0x3d, 0x30, 0x2a, 0x1b, 0x14, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x3f, 0x40, 0x41, 0x42, 0x42, 0x42, 
+	0x43, 0x44, 0x00, 0x42, 0x43, 0x40, 0x42, 0x43, 0x40, 
+	0x42, 0x41, 0x45, 0x46, 0x00, 0x00, 0x47, 0x42, 0x42, 
+	0x40, 0x42, 0x43, 0x40, 0x41, 0x42, 0x3f, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x06, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4b, 0x4c, 
+	0x4a, 0x4d, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x3a, 0x4f, 0x50, 0x51, 0x52, 0x4c, 0x4b, 0x4c, 
+	0x53, 0x54, 0x4d, 0x55, 0x00, 0x00, 0x53, 0x54, 0x56, 
+	0x4d, 0x4d, 0x4a, 0x57, 0x01, 0x00, 0x00, 0x00, 0x58, 
+	0x56, 0x4d, 0x54, 0x56, 0x4d, 0x56, 0x4f, 0x00, 0x00, 
+	0x4e, 0x53, 0x56, 0x4d, 0x54, 0x56, 0x4d, 0x56, 0x4d, 
+	0x4e, 0x00, 0x00, 0x06, 0x59, 0x54, 0x4d, 0x54, 0x4d, 
+	0x56, 0x54, 0x56, 0x54, 0x00, 0x00, 0x00, 0x57, 0x54, 
+	0x56, 0x4d, 0x4d, 0x4d, 0x54, 0x4d, 0x4a, 0x55, 0x00, 
+	0x00, 0x01, 0x54, 0x54, 0x56, 0x4d, 0x5a, 0x1b, 0x19, 
+	0x35, 0x37, 0x37, 0x37, 0x37, 0x37, 0x33, 0x19, 0x2a, 
+	0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 
+	0x5c, 0x5d, 0x5d, 0x5e, 0x5d, 0x5d, 0x5f, 0x60, 0x61, 
+	0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x62, 0x63, 0x3f, 
+	0x00, 0x00, 0x63, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 
+	0x5e, 0x64, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x4d, 0x4c, 0x66, 
+	0x66, 0x67, 0x67, 0x68, 0x67, 0x66, 0x4c, 0x69, 0x3b, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x4f, 0x4d, 0x4b, 0x4c, 
+	0x66, 0x68, 0x67, 0x67, 0x68, 0x66, 0x66, 0x4c, 0x6a, 
+	0x00, 0x00, 0x4c, 0x66, 0x66, 0x66, 0x66, 0x4c, 0x50, 
+	0x00, 0x00, 0x00, 0x00, 0x6b, 0x52, 0x66, 0x66, 0x66, 
+	0x66, 0x67, 0x6c, 0x00, 0x00, 0x57, 0x4b, 0x66, 0x66, 
+	0x66, 0x66, 0x66, 0x66, 0x66, 0x6b, 0x00, 0x00, 0x3c, 
+	0x66, 0x4c, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x4b, 
+	0x00, 0x00, 0x00, 0x6b, 0x4b, 0x66, 0x66, 0x68, 0x66, 
+	0x66, 0x66, 0x4b, 0x4f, 0x00, 0x00, 0x4f, 0x66, 0x66, 
+	0x66, 0x66, 0x66, 0x2a, 0x19, 0x37, 0x37, 0x37, 0x37, 
+	0x37, 0x37, 0x33, 0x19, 0x2a, 0x31, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x3f, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 
+	0x6f, 0x72, 0x73, 0x42, 0x74, 0x70, 0x6f, 0x70, 0x6f, 
+	0x71, 0x70, 0x75, 0x76, 0x47, 0x00, 0x00, 0x77, 0x6f, 
+	0x6f, 0x70, 0x71, 0x70, 0x6f, 0x71, 0x78, 0x79, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x3b, 0x51, 0x66, 0x67, 0x67, 0x67, 0x52, 0x67, 0x52, 
+	0x67, 0x67, 0x7a, 0x7b, 0x3b, 0x00, 0x00, 0x00, 0x3b, 
+	0x7c, 0x4c, 0x66, 0x4a, 0x68, 0x67, 0x52, 0x67, 0x52, 
+	0x67, 0x67, 0x67, 0x66, 0x6a, 0x00, 0x3a, 0x66, 0x67, 
+	0x67, 0x66, 0x67, 0x7a, 0x6c, 0x00, 0x00, 0x00, 0x00, 
+	0x6b, 0x67, 0x66, 0x4a, 0x52, 0x67, 0x53, 0x3c, 0x00, 
+	0x00, 0x50, 0x66, 0x66, 0x4a, 0x67, 0x66, 0x67, 0x52, 
+	0x67, 0x49, 0x00, 0x00, 0x48, 0x4b, 0x4a, 0x52, 0x67, 
+	0x67, 0x52, 0x67, 0x67, 0x4a, 0x00, 0x00, 0x01, 0x49, 
+	0x66, 0x67, 0x66, 0x52, 0x67, 0x67, 0x67, 0x4c, 0x48, 
+	0x00, 0x00, 0x7b, 0x52, 0x67, 0x67, 0x52, 0x67, 0x67, 
+	0x25, 0x7d, 0x37, 0x37, 0x37, 0x37, 0x7e, 0x2c, 0x19, 
+	0x1b, 0x7f, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x65, 
+	0x62, 0x70, 0x80, 0x70, 0x80, 0x70, 0x81, 0x00, 0x79, 
+	0x82, 0x70, 0x80, 0x70, 0x80, 0x72, 0x80, 0x70, 0x64, 
+	0x45, 0x00, 0x83, 0x6f, 0x70, 0x80, 0x70, 0x80, 0x70, 
+	0x80, 0x80, 0x6f, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x84, 0x67, 0x67, 0x52, 
+	0x68, 0x67, 0x67, 0x66, 0x4c, 0x4c, 0x7a, 0x4c, 0x69, 
+	0x3b, 0x00, 0x00, 0x01, 0x50, 0x4c, 0x52, 0x68, 0x52, 
+	0x67, 0x52, 0x68, 0x66, 0x4c, 0x7a, 0x4c, 0x4c, 0x4b, 
+	0x85, 0x00, 0x3c, 0x4c, 0x67, 0x52, 0x4a, 0x66, 0x4c, 
+	0x48, 0x00, 0x00, 0x00, 0x00, 0x7b, 0x4a, 0x66, 0x67, 
+	0x67, 0x68, 0x54, 0x3c, 0x00, 0x01, 0x6b, 0x4c, 0x52, 
+	0x67, 0x52, 0x4a, 0x66, 0x67, 0x67, 0x53, 0x00, 0x01, 
+	0x7c, 0x66, 0x67, 0x67, 0x67, 0x66, 0x67, 0x67, 0x66, 
+	0x49, 0x00, 0x00, 0x01, 0x51, 0x66, 0x67, 0x4a, 0x66, 
+	0x67, 0x66, 0x67, 0x66, 0x7b, 0x0e, 0x00, 0x54, 0x67, 
+	0x66, 0x67, 0x67, 0x66, 0x67, 0x2a, 0x7d, 0x37, 0x37, 
+	0x37, 0x37, 0x33, 0x19, 0x1c, 0x2a, 0x64, 0x86, 0x00, 
+	0x00, 0x00, 0x00, 0x46, 0x63, 0x71, 0x80, 0x70, 0x80, 
+	0x72, 0x61, 0x42, 0x00, 0x79, 0x6e, 0x80, 0x87, 0x80, 
+	0x87, 0x80, 0x70, 0x80, 0x74, 0x73, 0x00, 0x88, 0x70, 
+	0x80, 0x87, 0x80, 0x72, 0x80, 0x70, 0x6f, 0x77, 0x89, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x57, 0x67, 0x66, 0x4a, 0x52, 0x66, 0x67, 0x7c, 
+	0x6c, 0x48, 0x57, 0x49, 0x59, 0x06, 0x00, 0x00, 0x85, 
+	0x4c, 0x66, 0x67, 0x67, 0x67, 0x67, 0x66, 0x53, 0x7b, 
+	0x85, 0x6c, 0x48, 0x6b, 0x7c, 0x4e, 0x00, 0x3c, 0x66, 
+	0x67, 0x67, 0x67, 0x67, 0x7a, 0x6c, 0x00, 0x00, 0x00, 
+	0x00, 0x54, 0x52, 0x67, 0x67, 0x52, 0x67, 0x54, 0x39, 
+	0x00, 0x01, 0x50, 0x4c, 0x67, 0x68, 0x67, 0x66, 0x67, 
+	0x67, 0x52, 0x4a, 0x0e, 0x3b, 0x4a, 0x68, 0x67, 0x52, 
+	0x66, 0x4a, 0x52, 0x67, 0x66, 0x49, 0x00, 0x00, 0x01, 
+	0x49, 0x68, 0x67, 0x67, 0x66, 0x4a, 0x52, 0x67, 0x66, 
+	0x49, 0x01, 0x3a, 0x67, 0x66, 0x4a, 0x67, 0x66, 0x4a, 
+	0x52, 0x67, 0x2c, 0x7d, 0x37, 0x37, 0x37, 0x33, 0x19, 
+	0x1b, 0x72, 0x80, 0x63, 0x00, 0x00, 0x00, 0x00, 0x8a, 
+	0x77, 0x6f, 0x87, 0x80, 0x70, 0x75, 0x5f, 0x00, 0x00, 
+	0x79, 0x75, 0x70, 0x80, 0x70, 0x80, 0x70, 0x80, 0x87, 
+	0x6e, 0x65, 0x00, 0x6d, 0x72, 0x70, 0x80, 0x70, 0x80, 
+	0x87, 0x80, 0x6f, 0x62, 0x89, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x57, 0x67, 0x52, 
+	0x67, 0x68, 0x4a, 0x53, 0x84, 0x00, 0x00, 0x00, 0x3b, 
+	0x3c, 0x01, 0x00, 0x06, 0x8b, 0x67, 0x4a, 0x66, 0x67, 
+	0x67, 0x66, 0x49, 0x3c, 0x0e, 0x00, 0x00, 0x00, 0x00, 
+	0x01, 0x3b, 0x00, 0x3c, 0x66, 0x67, 0x52, 0x67, 0x66, 
+	0x66, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x56, 0x67, 0x66, 
+	0x67, 0x67, 0x68, 0x54, 0x8d, 0x00, 0x0e, 0x7b, 0x66, 
+	0x67, 0x52, 0x67, 0x4a, 0x66, 0x67, 0x67, 0x53, 0x3c, 
+	0x39, 0x7a, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 
+	0x66, 0x49, 0x00, 0x00, 0x00, 0x54, 0x66, 0x67, 0x52, 
+	0x67, 0x67, 0x67, 0x67, 0x66, 0x67, 0x0e, 0x85, 0x52, 
+	0x67, 0x52, 0x66, 0x67, 0x67, 0x67, 0x67, 0x19, 0x33, 
+	0x37, 0x37, 0x37, 0x7d, 0x19, 0x2a, 0x72, 0x80, 0x5e, 
+	0x00, 0x00, 0x00, 0x00, 0x5f, 0x75, 0x87, 0x80, 0x70, 
+	0x80, 0x8e, 0x45, 0x00, 0x00, 0x8f, 0x82, 0x72, 0x80, 
+	0x87, 0x80, 0x80, 0x72, 0x80, 0x75, 0x90, 0x45, 0x72, 
+	0x80, 0x87, 0x80, 0x72, 0x80, 0x70, 0x80, 0x6f, 0x62, 
+	0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x3c, 0x68, 0x67, 0x67, 0x52, 0x67, 0x67, 
+	0x49, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 
+	0x4a, 0x52, 0x67, 0x52, 0x67, 0x52, 0x51, 0x06, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6a, 
+	0x66, 0x67, 0x67, 0x67, 0x66, 0x54, 0x08, 0x00, 0x00, 
+	0x00, 0x00, 0x4d, 0x66, 0x4a, 0x52, 0x67, 0x52, 0x4d, 
+	0x06, 0x00, 0x06, 0x59, 0x66, 0x67, 0x67, 0x67, 0x51, 
+	0x67, 0x67, 0x52, 0x4a, 0x84, 0x48, 0x4c, 0x52, 0x68, 
+	0x4d, 0x54, 0x68, 0x67, 0x52, 0x68, 0x49, 0x00, 0x00, 
+	0x3b, 0x66, 0x67, 0x67, 0x67, 0x54, 0x54, 0x66, 0x67, 
+	0x67, 0x4c, 0x00, 0x69, 0x68, 0x67, 0x67, 0x53, 0x49, 
+	0x68, 0x52, 0x67, 0x19, 0x33, 0x37, 0x37, 0x7d, 0x33, 
+	0x19, 0x2a, 0x80, 0x70, 0x77, 0x83, 0x00, 0x00, 0x42, 
+	0x91, 0x75, 0x80, 0x72, 0x80, 0x75, 0x92, 0x00, 0x00, 
+	0x46, 0x5f, 0x71, 0x70, 0x80, 0x70, 0x5d, 0x77, 0x70, 
+	0x72, 0x75, 0x93, 0x65, 0x80, 0x72, 0x80, 0x64, 0x5c, 
+	0x70, 0x87, 0x80, 0x6f, 0x77, 0x89, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7b, 
+	0x66, 0x67, 0x67, 0x67, 0x66, 0x66, 0x56, 0x4f, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x50, 0x52, 0x68, 0x67, 0x67, 
+	0x67, 0x67, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x6c, 0x66, 0x67, 0x52, 0x67, 
+	0x66, 0x53, 0x6a, 0x00, 0x00, 0x00, 0x00, 0x56, 0x67, 
+	0x67, 0x68, 0x67, 0x66, 0x56, 0x0e, 0x00, 0x06, 0x49, 
+	0x66, 0x67, 0x66, 0x66, 0x69, 0x53, 0x52, 0x67, 0x67, 
+	0x57, 0x7c, 0x66, 0x67, 0x66, 0x69, 0x69, 0x66, 0x67, 
+	0x67, 0x66, 0x59, 0x00, 0x00, 0x00, 0x4c, 0x66, 0x67, 
+	0x52, 0x56, 0x51, 0x52, 0x67, 0x52, 0x4c, 0x8d, 0x4a, 
+	0x52, 0x67, 0x67, 0x69, 0x59, 0x66, 0x67, 0x67, 0x25, 
+	0x94, 0x7d, 0x37, 0x7d, 0x33, 0x19, 0x1b, 0x80, 0x70, 
+	0x64, 0x95, 0x00, 0x00, 0x8f, 0x6f, 0x80, 0x70, 0x80, 
+	0x70, 0x8e, 0x44, 0x00, 0x00, 0x46, 0x96, 0x75, 0x72, 
+	0x80, 0x6f, 0x91, 0x76, 0x70, 0x80, 0x71, 0x97, 0x98, 
+	0x72, 0x80, 0x70, 0x8e, 0x99, 0x75, 0x80, 0x70, 0x70, 
+	0x77, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x3b, 0x69, 0x4c, 0x52, 0x67, 
+	0x52, 0x4a, 0x66, 0x67, 0x85, 0x00, 0x00, 0x00, 0x00, 
+	0x4d, 0x4a, 0x67, 0x66, 0x67, 0x52, 0x4d, 0x06, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x48, 0x66, 0x67, 0x67, 0x67, 0x67, 0x4a, 0x3c, 0x00, 
+	0x00, 0x00, 0x3b, 0x4d, 0x68, 0x67, 0x52, 0x67, 0x52, 
+	0x56, 0x3b, 0x00, 0x3a, 0x51, 0x66, 0x67, 0x67, 0x66, 
+	0x57, 0x4a, 0x67, 0x66, 0x4a, 0x7c, 0x4a, 0x67, 0x67, 
+	0x68, 0x85, 0x50, 0x4c, 0x52, 0x67, 0x67, 0x49, 0x00, 
+	0x00, 0x3a, 0x4c, 0x67, 0x67, 0x66, 0x56, 0x69, 0x54, 
+	0x68, 0x67, 0x66, 0x9a, 0x4a, 0x67, 0x52, 0x53, 0x6c, 
+	0x49, 0x66, 0x67, 0x52, 0x2a, 0x19, 0x7d, 0x7d, 0x33, 
+	0x94, 0x1c, 0x2a, 0x80, 0x70, 0x80, 0x9b, 0x00, 0x44, 
+	0x9c, 0x75, 0x70, 0x80, 0x70, 0x75, 0x63, 0x00, 0x00, 
+	0x00, 0x46, 0x81, 0x71, 0x70, 0x80, 0x6f, 0x6d, 0x9d, 
+	0x71, 0x80, 0x6f, 0x6d, 0x5e, 0x80, 0x70, 0x80, 0x5c, 
+	0x79, 0x82, 0x72, 0x80, 0x6f, 0x62, 0x89, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x3b, 0x50, 0x4c, 0x67, 0x66, 0x67, 0x67, 0x66, 
+	0x66, 0x85, 0x00, 0x00, 0x00, 0x4d, 0x67, 0x52, 0x4a, 
+	0x66, 0x67, 0x4d, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x66, 0x67, 0x52, 
+	0x67, 0x66, 0x53, 0x6a, 0x00, 0x00, 0x00, 0x3b, 0x54, 
+	0x52, 0x67, 0x67, 0x67, 0x67, 0x4d, 0x3b, 0x00, 0x3c, 
+	0x54, 0x68, 0x67, 0x52, 0x4c, 0x3a, 0x4a, 0x52, 0x67, 
+	0x52, 0x54, 0x67, 0x52, 0x68, 0x4d, 0x48, 0x7b, 0x66, 
+	0x67, 0x67, 0x66, 0x49, 0x00, 0x00, 0x3c, 0x4c, 0x52, 
+	0x67, 0x66, 0x59, 0x4e, 0x51, 0x66, 0x67, 0x66, 0x54, 
+	0x67, 0x67, 0x67, 0x4a, 0x39, 0x68, 0x67, 0x67, 0x68, 
+	0x1b, 0x1c, 0x94, 0x33, 0x94, 0x1c, 0x2a, 0x1b, 0x87, 
+	0x80, 0x70, 0x5e, 0x45, 0x9e, 0x75, 0x70, 0x80, 0x87, 
+	0x80, 0x75, 0x83, 0x00, 0x00, 0x00, 0x3f, 0x5c, 0x70, 
+	0x80, 0x70, 0x75, 0x9f, 0xa0, 0x75, 0x72, 0x70, 0x5d, 
+	0x80, 0x87, 0x80, 0x72, 0x98, 0xa1, 0x6e, 0x87, 0x80, 
+	0x6f, 0x77, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x6b, 
+	0x66, 0x67, 0x67, 0x66, 0x67, 0x67, 0x66, 0x4f, 0x00, 
+	0x00, 0x51, 0x67, 0x68, 0x67, 0x66, 0x67, 0x54, 0x3a, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x7c, 0x68, 0x67, 0x67, 0x67, 0x66, 0x4a, 0x3c, 
+	0x00, 0x00, 0x00, 0x39, 0x4a, 0x67, 0x67, 0x68, 0x52, 
+	0x66, 0x4d, 0x3b, 0x00, 0x8d, 0x54, 0x66, 0x67, 0x67, 
+	0x4b, 0x01, 0x4d, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 
+	0x66, 0x69, 0x6a, 0x59, 0x66, 0x67, 0x68, 0x66, 0x57, 
+	0x00, 0x00, 0x8d, 0x4c, 0x67, 0x67, 0x66, 0x69, 0x84, 
+	0x59, 0x66, 0x67, 0x66, 0x4a, 0x52, 0x67, 0x52, 0x4d, 
+	0x01, 0x4b, 0x67, 0x52, 0x1c, 0x2a, 0x2a, 0x19, 0x33, 
+	0x19, 0x2a, 0x1b, 0x34, 0x80, 0x70, 0x80, 0x62, 0x5b, 
+	0x99, 0x82, 0x87, 0x80, 0x72, 0x75, 0x81, 0x0e, 0x00, 
+	0x00, 0x00, 0x3f, 0x5c, 0x6f, 0x87, 0x80, 0x6e, 0x5b, 
+	0x88, 0x71, 0x70, 0x80, 0x72, 0x80, 0x72, 0x80, 0x8e, 
+	0xa2, 0x99, 0x75, 0x80, 0x70, 0x71, 0x9c, 0x40, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x4f, 0x66, 0x67, 0x4a, 
+	0x66, 0x67, 0x4c, 0x49, 0x06, 0x00, 0x6b, 0x52, 0x67, 
+	0x52, 0x4a, 0x66, 0x67, 0x6b, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x69, 0x66, 0x52, 
+	0x68, 0x67, 0x52, 0x67, 0x6a, 0x00, 0x00, 0x00, 0x3c, 
+	0x53, 0x67, 0x66, 0x52, 0x4a, 0x66, 0x49, 0x00, 0x00, 
+	0x3c, 0x68, 0x52, 0x67, 0x52, 0x4c, 0x3b, 0x7b, 0x52, 
+	0x67, 0x66, 0x52, 0x67, 0x67, 0x4c, 0x6b, 0x38, 0x49, 
+	0x66, 0x67, 0x52, 0x66, 0x85, 0x00, 0x00, 0x4e, 0x66, 
+	0x68, 0x52, 0x68, 0x49, 0x3c, 0x50, 0x66, 0x67, 0x67, 
+	0x67, 0x67, 0x68, 0x4a, 0x85, 0x3b, 0x4c, 0x66, 0x1c, 
+	0x19, 0x2a, 0x1b, 0x19, 0x94, 0x19, 0x2a, 0x2a, 0x19, 
+	0x1c, 0x80, 0x70, 0x64, 0xa3, 0x5d, 0x70, 0x80, 0x70, 
+	0x70, 0x6f, 0x83, 0x00, 0x00, 0x00, 0x00, 0x3f, 0xa4, 
+	0x70, 0x80, 0x70, 0x82, 0xa5, 0xa6, 0x64, 0x80, 0x70, 
+	0x80, 0x70, 0x80, 0x70, 0x8e, 0x45, 0xa7, 0x75, 0x87, 
+	0x80, 0x75, 0x9c, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x4e, 0x58, 0x02, 0x00, 0x00, 
+	0x00, 0x01, 0x7b, 0x4c, 0x52, 0x67, 0x67, 0x66, 0x54, 
+	0x3a, 0x00, 0x4f, 0x4a, 0x67, 0x67, 0x52, 0x67, 0x66, 
+	0x4a, 0x6b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x39, 
+	0x06, 0x00, 0x49, 0x66, 0x4a, 0x67, 0x66, 0x67, 0x66, 
+	0x50, 0x00, 0x00, 0x00, 0x69, 0x67, 0x66, 0x4a, 0x68, 
+	0x67, 0x52, 0x51, 0x00, 0x00, 0x4e, 0x4b, 0x67, 0x67, 
+	0x68, 0x4c, 0x3b, 0x48, 0x4a, 0x66, 0x4a, 0x67, 0x67, 
+	0x52, 0x67, 0x4f, 0x3b, 0x51, 0x66, 0x67, 0x67, 0x4c, 
+	0x6c, 0x00, 0x00, 0x85, 0x66, 0x67, 0x67, 0x66, 0x51, 
+	0x38, 0x57, 0x4c, 0x52, 0x67, 0x66, 0x67, 0x52, 0x67, 
+	0x3c, 0x3b, 0x4b, 0x1c, 0x19, 0x19, 0x34, 0x2a, 0x1c, 
+	0x18, 0x18, 0x1b, 0x34, 0x19, 0x19, 0x1c, 0x80, 0x72, 
+	0x80, 0x72, 0x80, 0x87, 0x80, 0x82, 0x81, 0x45, 0x00, 
+	0x00, 0x00, 0x00, 0x45, 0x6e, 0x80, 0x70, 0x80, 0x6e, 
+	0x8f, 0x73, 0x5d, 0x70, 0x80, 0x87, 0x80, 0x70, 0x80, 
+	0x6d, 0x00, 0x63, 0x75, 0x72, 0x80, 0x75, 0x6d, 0x44, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x3c, 0x53, 0x4a, 0x67, 0x7c, 0x7b, 0x49, 0x66, 0x67, 
+	0x67, 0x68, 0x52, 0x66, 0x51, 0x06, 0x00, 0x00, 0x4d, 
+	0x67, 0x52, 0x67, 0x67, 0x67, 0x52, 0x52, 0x4a, 0x51, 
+	0x7b, 0x7b, 0x54, 0x67, 0x66, 0x06, 0x00, 0x6b, 0x66, 
+	0x67, 0x52, 0x4a, 0x66, 0x66, 0x66, 0x4d, 0x7b, 0x54, 
+	0x67, 0x52, 0x66, 0x67, 0x52, 0x67, 0x67, 0x6b, 0x00, 
+	0x00, 0x4f, 0x4c, 0x67, 0x52, 0x67, 0x66, 0x01, 0x4f, 
+	0x67, 0x67, 0x67, 0x66, 0x67, 0x66, 0x56, 0x39, 0x06, 
+	0x51, 0x66, 0x67, 0x52, 0x66, 0x85, 0x00, 0x00, 0x85, 
+	0x66, 0x67, 0x67, 0x66, 0x49, 0x3b, 0x85, 0x4c, 0x67, 
+	0x67, 0x4a, 0x66, 0x67, 0x4a, 0x00, 0x3b, 0x1e, 0x19, 
+	0x19, 0x1c, 0x1c, 0x12, 0xa8, 0x46, 0x00, 0x12, 0x18, 
+	0x19, 0x19, 0x19, 0x1e, 0x70, 0x80, 0x80, 0x87, 0x80, 
+	0x70, 0x70, 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 
+	0x6e, 0x80, 0x87, 0x80, 0x75, 0x5b, 0x40, 0x91, 0x6f, 
+	0x72, 0x80, 0x70, 0x80, 0x72, 0xa1, 0x00, 0x63, 0x75, 
+	0x80, 0x87, 0x75, 0x9c, 0x44, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x8d, 0x4a, 0x68, 0x52, 
+	0x68, 0x52, 0x67, 0x52, 0x67, 0x52, 0x67, 0x67, 0x4c, 
+	0x6b, 0x01, 0x00, 0x00, 0x8d, 0x4a, 0x68, 0x52, 0x67, 
+	0x66, 0x4a, 0x68, 0x67, 0x52, 0x68, 0x52, 0x67, 0x67, 
+	0x4c, 0x01, 0x00, 0x84, 0x66, 0x67, 0x67, 0x67, 0x66, 
+	0x4a, 0x67, 0x67, 0x66, 0x66, 0x67, 0x66, 0x4a, 0x67, 
+	0x67, 0x67, 0x54, 0x55, 0x00, 0x00, 0x85, 0x7a, 0x67, 
+	0x67, 0x66, 0x4d, 0x01, 0x39, 0x67, 0x52, 0x67, 0x67, 
+	0x67, 0x66, 0x69, 0x00, 0x06, 0x49, 0x66, 0x67, 0x67, 
+	0x66, 0x85, 0x00, 0x00, 0x50, 0x66, 0x52, 0x67, 0x66, 
+	0x7b, 0x00, 0x6a, 0x4a, 0x66, 0x67, 0x52, 0x67, 0x67, 
+	0x7b, 0x00, 0x06, 0x19, 0x19, 0x12, 0x12, 0x12, 0x4f, 
+	0x00, 0x00, 0x00, 0x46, 0x31, 0x18, 0x12, 0x1b, 0xa9, 
+	0x80, 0x87, 0x70, 0x80, 0x70, 0x75, 0xaa, 0x45, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x83, 0x75, 0x70, 0x80, 0x70, 
+	0x8e, 0x65, 0x00, 0x9c, 0x71, 0x80, 0x70, 0x80, 0x72, 
+	0x80, 0x73, 0x0e, 0x63, 0x75, 0x70, 0x72, 0x71, 0x6d, 
+	0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x3c, 0x53, 0x67, 0x67, 0x67, 0x67, 0x68, 0x67, 
+	0x67, 0x68, 0x52, 0x66, 0x4d, 0x02, 0x00, 0x00, 0x00, 
+	0x00, 0x3c, 0x53, 0x4a, 0x66, 0x67, 0x67, 0x52, 0x67, 
+	0x67, 0x67, 0x67, 0x67, 0x66, 0x51, 0x01, 0x00, 0x00, 
+	0x7b, 0x66, 0x52, 0x67, 0x52, 0x67, 0x52, 0x52, 0x67, 
+	0x4a, 0x66, 0x67, 0x52, 0x67, 0x52, 0x4a, 0x4f, 0x00, 
+	0x00, 0x01, 0x6b, 0x4c, 0x67, 0x67, 0x66, 0x56, 0x01, 
+	0x01, 0x4a, 0x67, 0x67, 0x52, 0x67, 0x66, 0x58, 0x00, 
+	0x55, 0x56, 0x66, 0x67, 0x67, 0x66, 0x85, 0x00, 0x00, 
+	0x49, 0x68, 0x67, 0x67, 0x66, 0x7c, 0x00, 0x3c, 0x4d, 
+	0x68, 0x67, 0x67, 0x67, 0x66, 0x4f, 0x00, 0x3a, 0xab, 
+	0xac, 0xad, 0xad, 0xad, 0x1d, 0x00, 0x00, 0x00, 0x00, 
+	0xad, 0xad, 0xad, 0x5e, 0x70, 0x80, 0x80, 0x80, 0x72, 
+	0x80, 0x87, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0xae, 0x75, 0x87, 0x80, 0x70, 0x8e, 0xaf, 0x00, 0x81, 
+	0x71, 0x80, 0x70, 0x80, 0x80, 0xb0, 0x00, 0x3f, 0xa9, 
+	0x75, 0x80, 0x80, 0x75, 0x9c, 0x44, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x4d, 0x68, 
+	0x52, 0x68, 0x67, 0x67, 0x67, 0x52, 0x52, 0x4a, 0x51, 
+	0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x7b, 
+	0x53, 0x67, 0x67, 0x67, 0x67, 0x67, 0x68, 0x52, 0x68, 
+	0x66, 0x69, 0x00, 0x00, 0x00, 0x00, 0x6c, 0x53, 0x4a, 
+	0x67, 0x67, 0x66, 0x4a, 0x68, 0x52, 0x67, 0x52, 0x67, 
+	0x4a, 0x51, 0x3c, 0x00, 0x00, 0x00, 0x01, 0x7b, 0x4c, 
+	0x52, 0x66, 0x66, 0x56, 0x3b, 0x00, 0x53, 0x66, 0x66, 
+	0x67, 0x52, 0x54, 0x08, 0x00, 0x6a, 0x53, 0x66, 0x66, 
+	0x52, 0x66, 0x85, 0x00, 0x00, 0x54, 0x66, 0x66, 0x66, 
+	0x4c, 0x7b, 0x00, 0x06, 0x4d, 0x68, 0x52, 0x66, 0x52, 
+	0x67, 0x06, 0x00, 0x4f, 0x4c, 0x52, 0x53, 0x2a, 0x29, 
+	0x15, 0x00, 0x00, 0x00, 0x00, 0x29, 0x15, 0x29, 0x70, 
+	0x80, 0x70, 0x70, 0x70, 0x70, 0x82, 0xaa, 0x45, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x75, 0x6f, 0x80, 
+	0x6f, 0x8e, 0xa6, 0x00, 0x63, 0x75, 0x70, 0x70, 0x70, 
+	0x70, 0xa0, 0x00, 0x47, 0x5d, 0x6f, 0x70, 0x70, 0x75, 
+	0x9c, 0xb1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x57, 0x49, 0x51, 0x4d, 0x54, 0x4d, 
+	0x54, 0x56, 0x69, 0x84, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x58, 0x49, 0x4d, 
+	0x4d, 0x54, 0x4d, 0x56, 0x56, 0x49, 0x4f, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x4e, 0x7b, 0x56, 0x4d, 0x56, 
+	0x4d, 0x56, 0x56, 0x51, 0x6b, 0x6a, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x3b, 0x6b, 0x4d, 0x51, 0x49, 0x4d, 0x7b, 
+	0x01, 0x00, 0x6b, 0x51, 0x49, 0x4d, 0x51, 0x7b, 0x06, 
+	0x00, 0x3c, 0x49, 0x51, 0x49, 0x4d, 0x56, 0x4e, 0x00, 
+	0x00, 0x4d, 0x51, 0x49, 0x51, 0x56, 0x57, 0x00, 0x01, 
+	0x6b, 0x4d, 0x51, 0x49, 0x56, 0x7c, 0x00, 0x00, 0x3c, 
+	0xb2, 0x17, 0xb2, 0x29, 0x17, 0x17, 0xb2, 0x00, 0x00, 
+	0xb2, 0x17, 0x17, 0x17, 0xb2, 0x17, 0xb2, 0x5c, 0x5c, 
+	0x76, 0x5c, 0x8a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x8f, 0x5e, 0x5c, 0x5c, 0x5e, 0x9b, 0x8a, 0x00, 
+	0x79, 0x5c, 0x5c, 0x5c, 0x5c, 0x76, 0x9e, 0x00, 0x45, 
+	0xb3, 0x76, 0x5c, 0x5c, 0x5d, 0x63, 0x45, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x3b, 0x3b, 0x3b, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x3b, 0x3b, 0x3b, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00 
+};
+
+// Keyboard
+
+unsigned char item_keyboard_colors[] = { 
+	0x00, 0x00, 0x00, 
+	0x18, 0x18, 0x18, 
+	0x39, 0x39, 0x39, 
+	0x31, 0x31, 0x31, 
+	0x29, 0x29, 0x29, 
+	0x21, 0x21, 0x21, 
+	0x42, 0x42, 0x42, 
+	0x63, 0x63, 0x63, 
+	0x7b, 0x7b, 0x7b, 
+	0x73, 0x73, 0x73, 
+	0x6b, 0x6b, 0x6b, 
+	0x4a, 0x4a, 0x4a, 
+	0x94, 0x94, 0x94, 
+	0x9c, 0x9c, 0x9c, 
+	0xa5, 0xa5, 0xa5, 
+	0xbd, 0xbd, 0xbd, 
+	0x5a, 0x5a, 0x5a, 
+	0x52, 0x52, 0x52, 
+	0x84, 0x84, 0x84, 
+	0xad, 0xad, 0xad, 
+	0xc6, 0xc6, 0xc6, 
+	0xb5, 0xb5, 0xb5, 
+	0x8c, 0x8c, 0x8c, 
+	0x10, 0x10, 0x10, 
+	0x08, 0x08, 0x08
+
+};
+unsigned char item_keyboard[] = { 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 
+	0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 
+	0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 
+	0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 
+	0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 
+	0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 
+	0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 
+	0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 
+	0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 
+	0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 
+	0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 
+	0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x00, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 
+	0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x06, 0x06, 0x06, 0x07, 0x08, 0x06, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x02, 0x09, 0x08, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 
+	0x0a, 0x08, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x08, 0x07, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x0b, 0x0c, 0x0d, 0x0d, 0x0b, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x0a, 0x08, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x0e, 0x0f, 0x10, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x0f, 
+	0x0f, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 
+	0x0a, 0x08, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x0d, 0x0e, 0x0d, 
+	0x0b, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x0a, 
+	0x0d, 0x0e, 0x0d, 0x11, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x06, 0x0a, 0x0d, 0x0e, 0x0d, 0x0d, 
+	0x0d, 0x06, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 
+	0x0a, 0x0d, 0x0e, 0x0d, 0x0d, 0x0d, 0x10, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x11, 0x0d, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x06, 0x10, 0x0d, 0x0d, 0x0d, 0x0d, 0x07, 0x03, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 
+	0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x0e, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 
+	0x06, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 
+	0x0e, 0x13, 0x08, 0x08, 0x06, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 
+	0x0e, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x07, 0x12, 0x0b, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x06, 0x0b, 0x06, 0x06, 0x08, 0x09, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x0e, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x06, 0x08, 0x12, 0x0f, 0x10, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x06, 0x06, 0x0b, 0x10, 0x12, 0x12, 0x0f, 0x10, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x10, 0x12, 0x12, 0x08, 0x08, 0x13, 0x08, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x10, 0x12, 0x12, 0x08, 
+	0x08, 0x0d, 0x0d, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x07, 0x0f, 0x06, 0x06, 0x07, 0x08, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x07, 0x14, 
+	0x08, 0x12, 0x08, 0x0b, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 
+	0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x06, 0x06, 0x0b, 0x06, 0x11, 0x11, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x12, 0x0d, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x0d, 0x08, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x0f, 0x07, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 
+	0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x12, 0x0d, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x12, 0x0d, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 
+	0x0f, 0x07, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 
+	0x0b, 0x06, 0x06, 0x0f, 0x07, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x06, 0x06, 0x06, 
+	0x06, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x0b, 0x06, 0x06, 0x06, 0x06, 0x08, 0x0d, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x07, 0x14, 0x06, 
+	0x06, 0x08, 0x0d, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x0b, 0x07, 0x0f, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x0b, 
+	0x06, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 0x11, 
+	0x13, 0x07, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 
+	0x0b, 0x06, 0x10, 0x0f, 0x0f, 0x14, 0x0e, 0x06, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x13, 0x0e, 
+	0x0f, 0x14, 0x08, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x11, 0x0e, 0x0f, 0x14, 0x0f, 0x0c, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x12, 
+	0x0f, 0x0f, 0x0e, 0x13, 0x08, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x06, 0x12, 0x0f, 0x0f, 0x14, 0x12, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x10, 
+	0x0f, 0x0f, 0x0f, 0x15, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x06, 0x12, 0x0f, 0x0f, 0x0e, 
+	0x0e, 0x09, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x12, 0x0e, 0x12, 0x15, 0x0f, 0x0e, 0x06, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x15, 0x0f, 0x0f, 
+	0x11, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x06, 0x0b, 0x0d, 0x0f, 0x14, 0x15, 0x03, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x0e, 0x06, 
+	0x06, 0x09, 0x15, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x0b, 0x06, 0x0f, 0x10, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0d, 0x0d, 
+	0x0f, 0x0e, 0x0e, 0x15, 0x07, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x0f, 
+	0x10, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x0d, 0x08, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 
+	0x06, 0x02, 0x08, 0x0d, 0x03, 0x03, 0x03, 0x00, 0x06, 
+	0x06, 0x0b, 0x07, 0x0f, 0x06, 0x06, 0x08, 0x0d, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x07, 
+	0x14, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 
+	0x0b, 0x06, 0x0b, 0x0c, 0x13, 0x06, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x06, 0x06, 0x11, 0x13, 0x0f, 0x07, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 
+	0x07, 0x10, 0x13, 0x09, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x12, 0x0f, 0x0c, 0x07, 0x0a, 0x15, 0x0a, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x11, 0x13, 
+	0x13, 0x07, 0x10, 0x10, 0x0b, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x09, 0x15, 0x09, 0x07, 0x16, 0x0f, 
+	0x08, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x09, 
+	0x15, 0x08, 0x07, 0x09, 0x0f, 0x0a, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x06, 0x06, 0x07, 0x14, 0x09, 0x11, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 
+	0x09, 0x15, 0x09, 0x07, 0x16, 0x0f, 0x08, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x12, 0x0f, 0x13, 0x09, 
+	0x10, 0x13, 0x09, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x06, 0x10, 0x07, 0x0f, 0x07, 0x02, 0x03, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x11, 
+	0x07, 0x09, 0x0f, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x12, 0x0d, 0x06, 0x0c, 0x15, 0x11, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x14, 0x10, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x0e, 0x15, 0x09, 0x0f, 0x0e, 0x16, 
+	0x0d, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x14, 0x10, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x11, 0x08, 0x12, 
+	0x08, 0x08, 0x13, 0x08, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x0b, 0x12, 0x12, 0x08, 0x13, 0x16, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x07, 0x0f, 
+	0x06, 0x06, 0x12, 0x0d, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x06, 0x07, 0x0f, 0x12, 0x08, 0x08, 
+	0x06, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x0c, 0x0f, 
+	0x0f, 0x13, 0x06, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x0b, 0x13, 
+	0x0f, 0x0f, 0x09, 0x10, 0x11, 0x11, 0x11, 0x0b, 0x0b, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 
+	0x06, 0x06, 0x06, 0x10, 0x12, 0x08, 0x08, 0x13, 0x08, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x0d, 
+	0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x06, 0x12, 0x13, 0x0b, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 
+	0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x12, 0x0d, 0x06, 0x02, 0x02, 
+	0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x0f, 0x10, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x0d, 0x06, 0x02, 
+	0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x12, 0x0e, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x0f, 0x10, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x10, 0x0f, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x0e, 
+	0x0d, 0x13, 0x11, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x0f, 0x10, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x0d, 
+	0x12, 0x06, 0x0f, 0x10, 0x08, 0x0d, 0x03, 0x03, 0x03, 
+	0x00, 0x00, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x0f, 0x10, 0x11, 0x10, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x06, 0x06, 0x08, 0x15, 0x0d, 0x0e, 0x0d, 0x0d, 0x0b, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x11, 
+	0x0d, 0x0d, 0x0d, 0x15, 0x08, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x06, 0x07, 0x0f, 0x12, 0x08, 0x0d, 0x13, 
+	0x06, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 
+	0x10, 0x0d, 0x0d, 0x0d, 0x15, 0x09, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 
+	0x06, 0x06, 0x0c, 0x14, 0x0f, 0x0f, 0x0f, 0x13, 0x06, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x02, 0x10, 0x15, 0x0f, 0x0f, 0x0e, 0x0e, 
+	0x0d, 0x0e, 0x0d, 0x0d, 0x0c, 0x06, 0x04, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x06, 0x11, 0x0f, 
+	0x0d, 0x0d, 0x0d, 0x14, 0x09, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x02, 0x06, 0x08, 0x0d, 0x02, 0x02, 0x02, 0x0d, 
+	0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x08, 
+	0x0d, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x02, 0x06, 0x08, 0x0d, 0x06, 0x02, 0x02, 
+	0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 
+	0x08, 0x15, 0x0d, 0x0d, 0x0d, 0x15, 0x08, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x02, 0x06, 0x02, 0x02, 0x14, 0x10, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 
+	0x06, 0x08, 0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x08, 0x0d, 0x06, 
+	0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x02, 0x06, 0x02, 0x02, 0x06, 0x0f, 0x10, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x02, 0x02, 
+	0x06, 0x02, 0x10, 0x0f, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x02, 0x06, 0x08, 0x0f, 0x0f, 0x0c, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x02, 
+	0x02, 0x06, 0x0f, 0x10, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x02, 0x06, 0x0d, 0x08, 0x02, 0x0f, 0x10, 
+	0x08, 0x0d, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 
+	0x02, 0x06, 0x02, 0x02, 0x06, 0x0f, 0x10, 0x08, 0x0d, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x02, 0x08, 0x0d, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x02, 0x02, 0x06, 0x02, 0x02, 0x02, 0x08, 
+	0x0d, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x11, 
+	0x0d, 0x0d, 0x0d, 0x13, 0x15, 0x06, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x02, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x0c, 0x0f, 0x0f, 
+	0x14, 0x0f, 0x0f, 0x0f, 0x0e, 0x02, 0x03, 0x03, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 
+	0x11, 0x15, 0x0f, 0x07, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x02, 0x08, 0x0e, 0x02, 0x02, 0x02, 0x16, 
+	0x0d, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x08, 
+	0x0d, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x02, 0x08, 0x13, 0x06, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 
+	0x08, 0x0d, 0x02, 0x02, 0x02, 0x0e, 0x08, 0x03, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x08, 0x13, 0x08, 0x08, 
+	0x08, 0x08, 0x0b, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x0f, 0x10, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x08, 0x13, 0x02, 
+	0x02, 0x0b, 0x13, 0x08, 0x03, 0x04, 0x04, 0x00, 0x02, 
+	0x02, 0x02, 0x08, 0x0d, 0x02, 0x02, 0x02, 0x08, 0x0d, 
+	0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x0f, 0x10, 0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x10, 0x0f, 
+	0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x08, 
+	0x13, 0x10, 0x15, 0x0c, 0x03, 0x03, 0x03, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0f, 0x10, 
+	0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 
+	0x0d, 0x08, 0x02, 0x14, 0x10, 0x11, 0x0f, 0x03, 0x04, 
+	0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x0f, 0x10, 0x08, 0x0d, 0x03, 0x04, 0x04, 0x00, 
+	0x02, 0x02, 0x02, 0x08, 0x0d, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x08, 0x0d, 0x03, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x08, 
+	0x0d, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x04, 
+	0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x10, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 
+	0x08, 0x07, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x11, 0x15, 0x10, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x03, 0x09, 
+	0x13, 0x10, 0x10, 0x07, 0x13, 0x0d, 0x04, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x02, 0x08, 0x0f, 0x16, 0x10, 0x0a, 
+	0x15, 0x07, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 
+	0x06, 0x13, 0x0e, 0x10, 0x11, 0x11, 0x06, 0x03, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x03, 0x0a, 0x15, 0x0a, 0x10, 
+	0x0c, 0x0f, 0x08, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x03, 0x0a, 0x15, 0x0a, 0x10, 0x11, 0x10, 0x02, 0x04, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x02, 0x02, 0x0f, 
+	0x10, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x00, 0x02, 
+	0x02, 0x02, 0x06, 0x15, 0x13, 0x0d, 0x0f, 0x15, 0x09, 
+	0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x08, 0x0d, 
+	0x02, 0x03, 0x03, 0x08, 0x0d, 0x04, 0x04, 0x04, 0x00, 
+	0x02, 0x02, 0x03, 0x02, 0x0b, 0x10, 0x0f, 0x0a, 0x10, 
+	0x03, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x02, 
+	0x02, 0x03, 0x02, 0x11, 0x14, 0x03, 0x04, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x02, 0x08, 0x0d, 0x02, 0x06, 0x0e, 
+	0x0c, 0x02, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 
+	0x02, 0x0b, 0x10, 0x0f, 0x0a, 0x10, 0x03, 0x04, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x02, 0x0f, 
+	0x10, 0x11, 0x0f, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x03, 0x06, 0x10, 0x10, 0x0f, 0x0a, 0x16, 
+	0x0d, 0x04, 0x04, 0x04, 0x00, 0x02, 0x03, 0x02, 0x08, 
+	0x13, 0x10, 0x11, 0x10, 0x11, 0x02, 0x03, 0x04, 0x04, 
+	0x00, 0x02, 0x03, 0x02, 0x06, 0x10, 0x10, 0x10, 0x11, 
+	0x16, 0x0d, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 
+	0x02, 0x02, 0x02, 0x03, 0x08, 0x0d, 0x03, 0x04, 0x04, 
+	0x04, 0x00, 0x02, 0x03, 0x02, 0x07, 0x16, 0x10, 0x10, 
+	0x11, 0x0e, 0x08, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 
+	0x02, 0x03, 0x02, 0x0b, 0x0b, 0x02, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x03, 0x03, 0x03, 0x06, 0x0e, 0x0f, 0x0f, 0x15, 
+	0x0d, 0x0c, 0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 
+	0x09, 0x0e, 0x0e, 0x0f, 0x0f, 0x08, 0x04, 0x03, 0x04, 
+	0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x06, 0x0e, 0x0f, 
+	0x14, 0x0f, 0x0c, 0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x08, 0x0f, 0x0f, 0x0c, 0x0e, 0x0a, 0x03, 
+	0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x0a, 0x15, 
+	0x0f, 0x0f, 0x0f, 0x09, 0x04, 0x04, 0x04, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x15, 0x0b, 0x03, 0x03, 0x04, 
+	0x03, 0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x06, 
+	0x09, 0x08, 0x11, 0x0d, 0x09, 0x04, 0x04, 0x04, 0x00, 
+	0x03, 0x03, 0x03, 0x09, 0x0c, 0x03, 0x02, 0x03, 0x0a, 
+	0x0c, 0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 
+	0x15, 0x0f, 0x14, 0x0f, 0x0f, 0x06, 0x03, 0x04, 0x05, 
+	0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x11, 
+	0x0f, 0x04, 0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 
+	0x09, 0x0c, 0x03, 0x03, 0x06, 0x0e, 0x09, 0x04, 0x04, 
+	0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x15, 0x0f, 0x14, 
+	0x0f, 0x0f, 0x06, 0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x0c, 0x09, 0x03, 0x15, 0x0b, 0x0b, 0x15, 0x04, 
+	0x04, 0x04, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x09, 
+	0x0f, 0x0f, 0x14, 0x0f, 0x0f, 0x0c, 0x03, 0x04, 0x05, 
+	0x00, 0x03, 0x03, 0x03, 0x08, 0x0f, 0x0f, 0x14, 0x0f, 
+	0x0f, 0x09, 0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 
+	0x09, 0x0f, 0x0f, 0x0f, 0x14, 0x0f, 0x0a, 0x04, 0x04, 
+	0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x09, 0x0c, 0x03, 0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 
+	0x03, 0x0b, 0x0c, 0x0f, 0x14, 0x0f, 0x15, 0x0b, 0x03, 
+	0x04, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x03, 0x04, 0x05, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 
+	0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x03, 
+	0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x00, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x0c, 
+	0x09, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 
+	0x03, 0x09, 0x06, 0x03, 0x11, 0x14, 0x04, 0x04, 0x05, 
+	0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x03, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x04, 
+	0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x03, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 
+	0x09, 0x09, 0x09, 0x0c, 0x14, 0x06, 0x04, 0x05, 0x05, 
+	0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 
+	0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x15, 0x0d, 0x09, 
+	0x0c, 0x13, 0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x03, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 
+	0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x03, 0x04, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 
+	0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x01, 0x04, 0x04, 0x04, 0x0c, 0x0d, 0x0d, 0x0c, 
+	0x02, 0x04, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 
+	0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 
+	0x04, 0x04, 0x06, 0x0c, 0x0d, 0x0c, 0x06, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x05, 0x05, 0x05, 0x18, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 
+	0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 
+	0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 
+	0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 
+	0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 
+	0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 
+	0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 
+	0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 
+	0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 
+	0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 
+	0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 
+	0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 
+	0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 
+	0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 
+	0x02, 0x03, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 
+	0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 
+	0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 
+	0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 
+	0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 
+	0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 
+	0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x05, 0x02, 0x06, 0x02, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 
+	0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 
+	0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x01, 0x00, 0x00, 0x00, 0x05, 0x02, 0x06, 0x02, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x01, 
+	0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x03, 0x01, 0x00, 0x05, 0x02, 0x06, 
+	0x02, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 
+	0x01, 0x00, 0x00, 0x00, 0x05, 0x02, 0x06, 0x02, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x01, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x06, 
+	0x0b, 0x02, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x10, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 
+	0x0a, 0x0d, 0x11, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x0a, 0x0d, 0x0e, 0x0d, 
+	0x0d, 0x0d, 0x12, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x06, 0x11, 0x0e, 0x0d, 0x0d, 0x0b, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x0a, 0x0d, 0x0e, 
+	0x0d, 0x0d, 0x0d, 0x07, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x11, 0x0d, 0x0e, 0x0d, 0x0d, 0x0d, 0x06, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x0b, 0x07, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x06, 0x0a, 0x0b, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x02, 0x11, 0x13, 0x0b, 0x03, 0x04, 
+	0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 
+	0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 
+	0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x06, 0x07, 0x0f, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x13, 0x0b, 0x06, 
+	0x06, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x08, 0x13, 0x12, 0x08, 0x08, 0x0e, 0x0d, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x07, 0x0f, 
+	0x12, 0x0f, 0x10, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x12, 0x13, 0x12, 0x08, 0x12, 0x13, 0x08, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x13, 
+	0x12, 0x08, 0x12, 0x13, 0x08, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x0b, 
+	0x13, 0x08, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x12, 0x13, 
+	0x0b, 0x06, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 
+	0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 
+	0x11, 0x15, 0x0b, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x11, 0x11, 
+	0x11, 0x07, 0x06, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 
+	0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x0b, 0x07, 0x14, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 
+	0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 
+	0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 0x06, 0x02, 0x02, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 
+	0x0b, 0x12, 0x0e, 0x06, 0x06, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x06, 0x06, 
+	0x06, 0x06, 0x08, 0x0d, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x0b, 0x07, 0x14, 0x06, 0x0f, 0x10, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x0e, 
+	0x06, 0x06, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x12, 0x0d, 0x06, 0x06, 0x02, 0x0d, 
+	0x08, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 
+	0x0b, 0x0b, 0x0b, 0x0b, 0x13, 0x0f, 0x08, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x0b, 0x0b, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x0b, 0x12, 0x0f, 0x13, 0x06, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 
+	0x0b, 0x0b, 0x06, 0x06, 0x02, 0x11, 0x15, 0x0b, 0x03, 
+	0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 
+	0x06, 0x0b, 0x08, 0x0d, 0x08, 0x15, 0x0f, 0x0e, 0x06, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x12, 
+	0x0f, 0x0f, 0x14, 0x08, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x12, 0x13, 0x13, 0x0f, 0x15, 0x11, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 
+	0x12, 0x0f, 0x0f, 0x0e, 0x0e, 0x09, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x0b, 0x08, 0x0d, 0x10, 0x13, 0x14, 
+	0x13, 0x0b, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 
+	0x11, 0x13, 0x0f, 0x14, 0x0f, 0x13, 0x0b, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x0b, 0x08, 0x0f, 0x0f, 0x0f, 
+	0x0f, 0x15, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x0b, 0x08, 0x0d, 0x06, 0x06, 0x06, 0x0c, 0x09, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x08, 0x0d, 0x06, 
+	0x06, 0x06, 0x09, 0x0c, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x15, 0x10, 0x06, 0x06, 0x06, 0x02, 0x15, 
+	0x0b, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x08, 0x13, 
+	0x0b, 0x06, 0x0b, 0x0e, 0x09, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x08, 0x0d, 0x06, 0x06, 0x06, 0x09, 
+	0x0c, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x08, 
+	0x0f, 0x0f, 0x0f, 0x14, 0x0f, 0x09, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 0x12, 0x0d, 0x06, 
+	0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 0x02, 0x08, 0x0d, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x07, 
+	0x0f, 0x06, 0x0f, 0x10, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x0b, 0x12, 0x13, 0x12, 0x08, 0x08, 0x13, 
+	0x08, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x12, 
+	0x0e, 0x06, 0x06, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x11, 0x13, 
+	0x0f, 0x0f, 0x08, 0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x10, 0x12, 0x12, 0x12, 0x12, 0x08, 0x12, 0x08, 0x08, 
+	0x07, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x12, 
+	0x0f, 0x0f, 0x13, 0x06, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x00, 0x00, 0x06, 0x06, 0x0b, 0x06, 0x0b, 0x06, 0x06, 
+	0x02, 0x11, 0x15, 0x0b, 0x03, 0x04, 0x04, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x06, 0x12, 0x0f, 
+	0x13, 0x09, 0x10, 0x13, 0x09, 0x03, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x09, 0x0f, 0x08, 0x07, 0x09, 0x13, 
+	0x0a, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x12, 
+	0x0f, 0x0d, 0x06, 0x0c, 0x0f, 0x0b, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x06, 0x09, 0x15, 0x08, 0x07, 0x16, 
+	0x0f, 0x08, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 
+	0x12, 0x13, 0x15, 0x12, 0x10, 0x0d, 0x0c, 0x03, 0x03, 
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x12, 0x15, 0x07, 0x07, 
+	0x10, 0x16, 0x07, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 
+	0x06, 0x11, 0x09, 0x14, 0x07, 0x10, 0x11, 0x03, 0x03, 
+	0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x12, 0x0d, 0x06, 
+	0x06, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x06, 
+	0x06, 0x06, 0x12, 0x0e, 0x06, 0x06, 0x02, 0x12, 0x0d, 
+	0x03, 0x03, 0x03, 0x00, 0x06, 0x06, 0x06, 0x0f, 0x07, 
+	0x06, 0x06, 0x02, 0x02, 0x0f, 0x11, 0x03, 0x03, 0x00, 
+	0x06, 0x06, 0x06, 0x06, 0x13, 0x0e, 0x06, 0x0d, 0x0e, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x12, 
+	0x0d, 0x06, 0x06, 0x02, 0x12, 0x0d, 0x03, 0x03, 0x03, 
+	0x00, 0x06, 0x06, 0x06, 0x11, 0x07, 0x07, 0x07, 0x12, 
+	0x0f, 0x07, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 
+	0x06, 0x06, 0x12, 0x0d, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x06, 0x06, 0x07, 0x15, 0x12, 0x03, 0x03, 0x03, 0x00, 
+	0x06, 0x06, 0x06, 0x11, 0x16, 0x0f, 0x12, 0x0f, 0x12, 
+	0x06, 0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x06, 0x0a, 
+	0x0d, 0x0e, 0x0d, 0x0e, 0x15, 0x08, 0x03, 0x03, 0x04, 
+	0x00, 0x06, 0x06, 0x06, 0x12, 0x0d, 0x06, 0x06, 0x06, 
+	0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 
+	0x06, 0x06, 0x11, 0x0e, 0x0f, 0x0f, 0x14, 0x08, 0x02, 
+	0x03, 0x03, 0x04, 0x00, 0x06, 0x06, 0x0c, 0x0f, 0x0f, 
+	0x0f, 0x0f, 0x0f, 0x0f, 0x0e, 0x06, 0x03, 0x04, 0x00, 
+	0x06, 0x06, 0x06, 0x06, 0x12, 0x0f, 0x0f, 0x14, 0x0e, 
+	0x06, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x11, 0x15, 0x0b, 
+	0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x02, 0x06, 0x06, 0x08, 0x13, 0x06, 0x02, 0x02, 0x0d, 
+	0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 
+	0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x12, 0x13, 0x06, 0x02, 0x02, 
+	0x13, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x12, 0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x06, 0x06, 0x12, 0x15, 0x11, 0x02, 
+	0x02, 0x07, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 
+	0x06, 0x11, 0x15, 0x13, 0x08, 0x06, 0x02, 0x02, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 0x07, 0x0f, 
+	0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x06, 0x06, 0x12, 0x13, 0x06, 0x02, 0x02, 0x0d, 0x08, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x11, 0x14, 
+	0x0b, 0x06, 0x02, 0x13, 0x0a, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x06, 0x13, 0x09, 0x06, 0x15, 0x11, 0x0b, 
+	0x0f, 0x06, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 
+	0x0b, 0x15, 0x15, 0x15, 0x06, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x11, 0x14, 0x0b, 0x06, 0x02, 
+	0x13, 0x09, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x06, 0x06, 0x06, 0x07, 0x14, 0x07, 0x02, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x02, 0x06, 0x06, 0x12, 0x13, 
+	0x12, 0x08, 0x08, 0x08, 0x0b, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x0a, 0x0f, 0x07, 
+	0x02, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x08, 
+	0x15, 0x0d, 0x0d, 0x0d, 0x15, 0x09, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 0x02, 0x02, 
+	0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 
+	0x12, 0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 
+	0x04, 0x00, 0x00, 0x00, 0x02, 0x06, 0x06, 0x06, 0x0c, 
+	0x14, 0x0f, 0x0f, 0x08, 0x02, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x06, 0x06, 0x0c, 0x14, 0x0f, 0x14, 0x0f, 0x13, 
+	0x06, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x06, 0x06, 
+	0x12, 0x0f, 0x0f, 0x0f, 0x0c, 0x02, 0x03, 0x03, 0x04, 
+	0x00, 0x00, 0x00, 0x02, 0x06, 0x06, 0x06, 0x06, 0x06, 
+	0x02, 0x02, 0x11, 0x15, 0x0b, 0x03, 0x04, 0x04, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x06, 0x08, 
+	0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x02, 0x06, 0x08, 0x0d, 0x06, 0x02, 0x02, 
+	0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 
+	0x08, 0x0d, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x02, 0x06, 0x08, 0x0d, 0x02, 0x02, 
+	0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 
+	0x06, 0x08, 0x0d, 0x06, 0x02, 0x02, 0x02, 0x03, 0x03, 
+	0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x02, 0x0b, 0x08, 
+	0x13, 0x15, 0x12, 0x03, 0x03, 0x03, 0x04, 0x00, 0x02, 
+	0x02, 0x06, 0x02, 0x10, 0x0f, 0x02, 0x02, 0x02, 0x03, 
+	0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x10, 0x0f, 
+	0x02, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 
+	0x02, 0x02, 0x06, 0x02, 0x0e, 0x16, 0x02, 0x0a, 0x15, 
+	0x06, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 0x0d, 
+	0x08, 0x02, 0x0f, 0x10, 0x10, 0x0f, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x02, 0x06, 0x02, 0x02, 0x08, 0x0f, 0x08, 
+	0x03, 0x03, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 
+	0x02, 0x13, 0x12, 0x02, 0x0a, 0x15, 0x06, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x02, 0x06, 0x02, 0x02, 0x0a, 0x0f, 
+	0x07, 0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x06, 0x08, 0x15, 0x0d, 0x0d, 0x0d, 0x15, 
+	0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x02, 0x02, 
+	0x06, 0x02, 0x0f, 0x09, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x06, 0x02, 0x08, 0x0d, 0x06, 0x02, 0x02, 
+	0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x02, 0x02, 0x06, 
+	0x02, 0x02, 0x06, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x03, 
+	0x04, 0x00, 0x02, 0x02, 0x06, 0x08, 0x0d, 0x06, 0x02, 
+	0x02, 0x0d, 0x08, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x06, 0x02, 0x06, 0x0c, 0x0f, 0x0f, 0x08, 
+	0x03, 0x03, 0x03, 0x04, 0x00, 0x02, 0x06, 0x02, 0x06, 
+	0x0c, 0x0f, 0x0f, 0x13, 0x06, 0x03, 0x03, 0x03, 0x04, 
+	0x00, 0x02, 0x02, 0x06, 0x02, 0x08, 0x14, 0x0f, 0x0c, 
+	0x02, 0x03, 0x03, 0x03, 0x04, 0x00, 0x00, 0x00, 0x02, 
+	0x02, 0x06, 0x02, 0x02, 0x06, 0x11, 0x02, 0x11, 0x13, 
+	0x0b, 0x03, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x02, 0x08, 0x0d, 0x02, 0x02, 0x02, 
+	0x08, 0x0d, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 
+	0x08, 0x0d, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x08, 0x13, 0x02, 0x02, 
+	0x02, 0x0e, 0x08, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x02, 0x08, 0x0d, 0x02, 0x02, 0x02, 0x0e, 0x08, 0x03, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x08, 0x0d, 0x02, 
+	0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0a, 0x15, 0x0a, 
+	0x04, 0x03, 0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 0x10, 
+	0x14, 0x02, 0x02, 0x06, 0x06, 0x03, 0x04, 0x04, 0x00, 
+	0x02, 0x02, 0x02, 0x10, 0x14, 0x02, 0x02, 0x02, 0x0e, 
+	0x08, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x10, 0x0f, 0x06, 0x0e, 0x08, 0x03, 0x03, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x02, 0x0d, 0x16, 0x11, 0x0f, 0x09, 
+	0x07, 0x15, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x11, 0x15, 0x12, 0x15, 0x0b, 0x03, 0x03, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 0x0a, 0x15, 0x02, 
+	0x0e, 0x12, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x02, 0x02, 0x0a, 0x0f, 0x0a, 0x02, 0x03, 0x03, 0x03, 
+	0x04, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x08, 
+	0x0d, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0f, 0x10, 
+	0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 
+	0x08, 0x0d, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x03, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x0d, 0x08, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x02, 0x08, 0x0d, 0x02, 0x02, 0x02, 0x0d, 0x08, 0x03, 
+	0x04, 0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x0c, 0x0f, 0x08, 0x03, 0x03, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0c, 0x0e, 0x06, 
+	0x03, 0x03, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 0x02, 
+	0x02, 0x08, 0x0f, 0x0c, 0x02, 0x03, 0x03, 0x03, 0x04, 
+	0x04, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 0x0b, 
+	0x0d, 0x0e, 0x10, 0x07, 0x15, 0x0b, 0x04, 0x04, 0x04, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x03, 
+	0x08, 0x0d, 0x02, 0x03, 0x03, 0x08, 0x0d, 0x04, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x02, 0x0a, 0x15, 0x0a, 0x10, 
+	0x0a, 0x0f, 0x07, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x03, 0x08, 0x0f, 0x0c, 0x02, 0x16, 0x0f, 0x0b, 0x04, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x0a, 0x14, 0x0a, 
+	0x10, 0x0c, 0x14, 0x09, 0x03, 0x04, 0x04, 0x00, 0x02, 
+	0x02, 0x03, 0x08, 0x0d, 0x02, 0x03, 0x03, 0x03, 0x03, 
+	0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x07, 0x12, 
+	0x10, 0x10, 0x11, 0x13, 0x09, 0x04, 0x04, 0x04, 0x00, 
+	0x02, 0x02, 0x03, 0x02, 0x0b, 0x0f, 0x07, 0x11, 0x0e, 
+	0x0d, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x11, 
+	0x0f, 0x07, 0x0a, 0x13, 0x0f, 0x08, 0x04, 0x04, 0x04, 
+	0x00, 0x02, 0x02, 0x03, 0x02, 0x02, 0x13, 0x0c, 0x0f, 
+	0x06, 0x03, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 
+	0x07, 0x15, 0x15, 0x0d, 0x0f, 0x13, 0x08, 0x03, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x03, 0x06, 0x15, 0x12, 0x02, 
+	0x12, 0x15, 0x02, 0x03, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x03, 0x02, 0x06, 0x15, 0x0e, 0x0f, 0x06, 0x03, 0x04, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x07, 0x0f, 0x12, 
+	0x10, 0x11, 0x11, 0x06, 0x04, 0x04, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x03, 0x08, 0x13, 0x10, 0x10, 0x11, 
+	0x0e, 0x08, 0x04, 0x04, 0x04, 0x00, 0x02, 0x03, 0x02, 
+	0x02, 0x03, 0x02, 0x0f, 0x10, 0x03, 0x03, 0x04, 0x04, 
+	0x04, 0x00, 0x02, 0x03, 0x02, 0x08, 0x13, 0x10, 0x11, 
+	0x10, 0x0e, 0x08, 0x04, 0x04, 0x04, 0x00, 0x02, 0x02, 
+	0x03, 0x02, 0x02, 0x03, 0x02, 0x03, 0x0e, 0x08, 0x04, 
+	0x04, 0x04, 0x00, 0x02, 0x02, 0x03, 0x08, 0x13, 0x11, 
+	0x10, 0x11, 0x0e, 0x08, 0x04, 0x04, 0x04, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x03, 0x02, 0x03, 0x02, 0x02, 0x16, 
+	0x08, 0x03, 0x04, 0x04, 0x04, 0x00, 0x02, 0x03, 0x02, 
+	0x02, 0x03, 0x02, 0x06, 0x03, 0x03, 0x03, 0x04, 0x04, 
+	0x04, 0x00, 0x02, 0x02, 0x03, 0x02, 0x08, 0x0c, 0x02, 
+	0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 
+	0x02, 0x02, 0x03, 0x02, 0x09, 0x0f, 0x13, 0x0d, 0x0e, 
+	0x15, 0x11, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x03, 0x03, 0x09, 0x0c, 0x03, 0x02, 
+	0x03, 0x0a, 0x0c, 0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x08, 0x15, 0x0f, 0x15, 0x08, 0x04, 0x03, 
+	0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x08, 0x13, 0x15, 
+	0x0f, 0x15, 0x0b, 0x04, 0x03, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x08, 0x0f, 0x0f, 0x0c, 0x0d, 0x09, 
+	0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 0x09, 0x0c, 
+	0x03, 0x02, 0x03, 0x03, 0x04, 0x03, 0x04, 0x05, 0x00, 
+	0x03, 0x03, 0x03, 0x0b, 0x13, 0x0f, 0x0f, 0x14, 0x0d, 
+	0x02, 0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x12, 0x0f, 0x0f, 0x13, 0x06, 0x03, 0x04, 0x04, 
+	0x00, 0x03, 0x03, 0x03, 0x03, 0x0c, 0x0f, 0x15, 0x08, 
+	0x0c, 0x09, 0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x10, 0x0f, 0x16, 0x03, 0x04, 0x03, 0x04, 
+	0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x15, 0x0e, 0x03, 
+	0x12, 0x0f, 0x0b, 0x04, 0x04, 0x04, 0x00, 0x03, 0x03, 
+	0x03, 0x09, 0x0e, 0x03, 0x03, 0x03, 0x0e, 0x0a, 0x04, 
+	0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x10, 
+	0x13, 0x16, 0x03, 0x04, 0x03, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x09, 0x0f, 0x0f, 0x14, 0x0f, 0x0f, 0x09, 
+	0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 
+	0x09, 0x0f, 0x0f, 0x0f, 0x14, 0x0f, 0x09, 0x04, 0x04, 
+	0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x15, 
+	0x0b, 0x03, 0x04, 0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x11, 0x15, 0x0f, 0x0f, 0x0f, 0x15, 0x0b, 0x04, 
+	0x04, 0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x0b, 0x0f, 0x09, 0x04, 0x04, 0x04, 0x00, 0x03, 
+	0x03, 0x03, 0x11, 0x15, 0x0f, 0x0f, 0x14, 0x15, 0x0b, 
+	0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x0b, 0x03, 0x04, 0x04, 
+	0x04, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x03, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x11, 0x03, 0x03, 0x03, 0x03, 0x04, 0x03, 
+	0x04, 0x05, 0x00, 0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 
+	0x02, 0x09, 0x0c, 0x06, 0x02, 0x02, 0x03, 0x04, 0x04, 
+	0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x03, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x09, 0x0d, 0x02, 0x11, 0x02, 0x03, 0x04, 
+	0x04, 0x05, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x0d, 0x09, 0x04, 0x04, 0x05, 0x00, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x05, 0x05, 0x00, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x04, 0x03, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x04, 0x03, 0x03, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 
+	0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x06, 0x0f, 0x0b, 0x03, 0x04, 
+	0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 
+	0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 
+	0x00, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 0x00, 0x03, 0x03, 
+	0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x03, 0x04, 0x03, 0x04, 0x04, 0x04, 0x05, 0x00, 0x00, 
+	0x00, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x03, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x09, 0x0d, 
+	0x03, 0x04, 0x03, 0x04, 0x04, 0x05, 0x04, 0x05, 0x00, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x0c, 
+	0x09, 0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 
+	0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 
+	0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x03, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x06, 0x09, 
+	0x0d, 0x0e, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x00, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 
+	0x04, 0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 
+	0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x03, 
+	0x04, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 0x04, 0x04, 
+	0x05, 0x05, 0x00, 0x04, 0x03, 0x04, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x04, 0x05, 0x05, 0x05, 0x00, 0x04, 
+	0x03, 0x04, 0x04, 0x03, 0x04, 0x03, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x03, 0x04, 
+	0x04, 0x03, 0x04, 0x03, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x01, 0x04, 0x04, 0x11, 0x09, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x09, 0x11, 0x05, 0x05, 0x17, 
+	0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 
+	0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x05, 0x04, 0x17, 0x00, 0x01, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x01, 0x04, 0x04, 0x11, 0x0d, 0x0d, 0x11, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x00, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x00, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 0x01, 
+	0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x01, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 
+	0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x18, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 
+	0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 
+	0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 
+	0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 
+	0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 
+	0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 
+	0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 
+	0x05, 0x05, 0x00, 0x00, 0x00, 0x04, 0x05, 0x04, 0x05, 
+	0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 0x05, 0x00, 0x00, 
+	0x00, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 
+	0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 
+	0x05, 0x04, 0x05, 0x04, 0x05, 0x04, 0x05, 0x05, 0x05, 
+	0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 
+	0x05, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x17, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x17, 0x05, 0x05, 0x05, 
+	0x05, 0x05, 0x05, 0x05, 0x01, 0x17, 0x00, 0x00, 0x00, 
+	0x00, 0x00 
+};
+
+// *************************************************************************
+//									 ICONS
+// *************************************************************************
+
+// File
+
+unsigned char item_disk_colors[] = { 
+	0x00, 0x00, 0x00, 
+	0x93, 0x7d, 0x2d, 
+	0x7b, 0x68, 0x25, 
+	0xc1, 0xaf, 0x6b, 
+	0xa3, 0x94, 0x59, 
+	0x05, 0x04, 0x00, 
+	0x55, 0x48, 0x15, 
+	0xa0, 0x87, 0x2f, 
+	0xa3, 0x8b, 0x33, 
+	0xdf, 0xcc, 0x88, 
+	0xe4, 0xd0, 0x89, 
+	0xc7, 0xaf, 0x62, 
+	0xab, 0x9a, 0x51, 
+	0x16, 0x10, 0x01, 
+	0x0a, 0x09, 0x00, 
+	0x7a, 0x67, 0x24, 
+	0xac, 0x93, 0x3b, 
+	0xb0, 0x97, 0x3f, 
+	0xf1, 0xdc, 0x94, 
+	0xd9, 0xc2, 0x73, 
+	0xdb, 0xc3, 0x6a, 
+	0xca, 0xb2, 0x54, 
+	0xaa, 0x99, 0x4e, 
+	0x90, 0x79, 0x2a, 
+	0x9d, 0x84, 0x2d, 
+	0xe2, 0xcc, 0x72, 
+	0xf3, 0xda, 0x77, 
+	0xe3, 0xcc, 0x69, 
+	0xe3, 0xca, 0x62, 
+	0xdb, 0xc3, 0x64, 
+	0xc8, 0xad, 0x59, 
+	0xa1, 0x90, 0x53, 
+	0x75, 0x62, 0x21, 
+	0x8d, 0x76, 0x28, 
+	0x96, 0x7e, 0x2a, 
+	0xde, 0xc5, 0x5a, 
+	0xe7, 0xd1, 0x64, 
+	0xe5, 0xcb, 0x5e, 
+	0xd2, 0xb8, 0x69, 
+	0xbd, 0xa9, 0x62, 
+	0x9c, 0x8c, 0x53, 
+	0x8a, 0x74, 0x26, 
+	0x09, 0x09, 0x04, 
+	0xd4, 0xbb, 0x64, 
+	0xe0, 0xc5, 0x5e, 
+	0xe3, 0xc7, 0x64, 
+	0xd6, 0xc0, 0x67, 
+	0xcd, 0xb3, 0x64, 
+	0xbd, 0xa9, 0x5b, 
+	0x9d, 0x8d, 0x4e, 
+	0x72, 0x60, 0x1e, 
+	0xd0, 0xba, 0x72, 
+	0xd3, 0xb8, 0x51, 
+	0xd1, 0xb5, 0x59, 
+	0xe0, 0xc7, 0x6e, 
+	0x8f, 0x78, 0x25, 
+	0x88, 0x71, 0x23, 
+	0xc4, 0xb0, 0x65, 
+	0xd4, 0xba, 0x5c, 
+	0xc4, 0xae, 0x5b, 
+	0x98, 0x7f, 0x23, 
+	0x84, 0x6e, 0x21, 
+	0x8e, 0x76, 0x24, 
+	0x93, 0x7a, 0x24, 
+	0x86, 0x70, 0x21, 
+	0x71, 0x5e, 0x1d, 
+	0xba, 0xa5, 0x5d, 
+	0xb6, 0xa1, 0x5a, 
+	0xbf, 0xa8, 0x52, 
+	0xc3, 0xac, 0x52, 
+	0xc5, 0xac, 0x4b, 
+	0x5a, 0x4b, 0x16, 
+	0x75, 0x61, 0x1d, 
+	0x89, 0x71, 0x1d, 
+	0x6d, 0x61, 0x35, 
+	0x77, 0x69, 0x3a, 
+	0x83, 0x74, 0x40, 
+	0x94, 0x84, 0x48, 
+	0xb1, 0x9e, 0x53, 
+	0xb8, 0xa4, 0x52, 
+	0xc5, 0xab, 0x47, 
+	0x34, 0x2b, 0x0d, 
+	0x7a, 0x65, 0x1d, 
+	0x84, 0x6c, 0x1d, 
+	0x89, 0x70, 0x1b, 
+	0x8c, 0x74, 0x1e, 
+	0x66, 0x54, 0x18, 
+	0x16, 0x14, 0x0b, 
+	0x38, 0x31, 0x1b, 
+	0x63, 0x56, 0x2e, 
+	0x89, 0x78, 0x40, 
+	0xb6, 0xa1, 0x4f, 
+	0xbb, 0xa3, 0x4d, 
+	0xc1, 0xa7, 0x4a, 
+	0xbf, 0xa5, 0x4b, 
+	0xb3, 0x9c, 0x46, 
+	0xc2, 0xc2, 0xc2, 
+	0x4e, 0x4e, 0x4e, 
+	0x57, 0x4c, 0x23, 
+	0x81, 0x69, 0x15, 
+	0x83, 0x6d, 0x20, 
+	0x23, 0x1d, 0x08, 
+	0x3d, 0x36, 0x1a, 
+	0x6f, 0x62, 0x2f, 
+	0xac, 0x97, 0x48, 
+	0xa8, 0x93, 0x42, 
+	0xb8, 0xa1, 0x47, 
+	0xb8, 0xa0, 0x48, 
+	0xb6, 0x9f, 0x49, 
+	0xaf, 0x99, 0x47, 
+	0xff, 0xff, 0xff, 
+	0x85, 0x6d, 0x19, 
+	0x6f, 0x5c, 0x1b, 
+	0x11, 0x4d, 0x81, 
+	0x26, 0x71, 0xa5, 
+	0x26, 0x6e, 0xa4, 
+	0x1c, 0x5e, 0x94, 
+	0x0b, 0x3d, 0x69, 
+	0x45, 0x3d, 0x1d, 
+	0xaa, 0x95, 0x49, 
+	0xac, 0x97, 0x47, 
+	0xaa, 0x94, 0x45, 
+	0xa8, 0x93, 0x45, 
+	0x28, 0x79, 0xa9, 
+	0x35, 0x81, 0xb4, 
+	0x3e, 0x87, 0xb9, 
+	0x33, 0x7b, 0xaf, 
+	0x21, 0x65, 0x9e, 
+	0x21, 0x61, 0x9c, 
+	0x1e, 0x5b, 0x98, 
+	0x15, 0x4e, 0x8a, 
+	0x44, 0x3b, 0x1e, 
+	0x99, 0x84, 0x39, 
+	0xa2, 0x8d, 0x41, 
+	0x9e, 0x89, 0x3d, 
+	0x32, 0x29, 0x0a, 
+	0x81, 0x69, 0x19, 
+	0x2d, 0x80, 0xb0, 
+	0x3b, 0x89, 0xbb, 
+	0x65, 0xa5, 0xd0, 
+	0x58, 0x9d, 0xcc, 
+	0x4a, 0x8f, 0xc2, 
+	0x2f, 0x71, 0xaa, 
+	0x1d, 0x58, 0x96, 
+	0x19, 0x51, 0x82, 
+	0x0e, 0x42, 0x85, 
+	0x7a, 0x6a, 0x31, 
+	0x95, 0x7f, 0x35, 
+	0x9d, 0x87, 0x3c, 
+	0xa1, 0x8b, 0x40, 
+	0x88, 0x6f, 0x1b, 
+	0x59, 0x49, 0x12, 
+	0x7f, 0x69, 0x1e, 
+	0x0e, 0x62, 0x91, 
+	0x4b, 0x98, 0xcb, 
+	0xd1, 0xf0, 0xfe, 
+	0x93, 0xda, 0xfe, 
+	0x56, 0x9a, 0xd0, 
+	0x38, 0x78, 0xb2, 
+	0x28, 0x65, 0xa2, 
+	0x1c, 0x54, 0x94, 
+	0x1c, 0x55, 0x7d, 
+	0x2a, 0x55, 0x76, 
+	0x13, 0x24, 0x3e, 
+	0x8b, 0x75, 0x2b, 
+	0x99, 0x83, 0x37, 
+	0x95, 0x7f, 0x32, 
+	0x30, 0x27, 0x09, 
+	0x70, 0x5c, 0x16, 
+	0x3e, 0x89, 0xbd, 
+	0x52, 0x9d, 0xd1, 
+	0x7c, 0xc3, 0xfa, 
+	0x6e, 0xb2, 0xeb, 
+	0x51, 0x92, 0xcc, 
+	0x39, 0x77, 0xb2, 
+	0x20, 0x5e, 0x9b, 
+	0x1b, 0x52, 0x93, 
+	0x2b, 0x55, 0x70, 
+	0x32, 0x55, 0x67, 
+	0x13, 0x29, 0x4e, 
+	0x23, 0x1e, 0x0e, 
+	0x7c, 0x67, 0x1e, 
+	0x91, 0x7a, 0x2d, 
+	0x63, 0x51, 0x12, 
+	0x80, 0x6b, 0x23, 
+	0x2a, 0x77, 0xaa, 
+	0x45, 0x88, 0xc1, 
+	0x44, 0x84, 0xbf, 
+	0x3a, 0x78, 0xb4, 
+	0x2c, 0x67, 0xa4, 
+	0x1c, 0x53, 0x81, 
+	0x2f, 0x56, 0x69, 
+	0x31, 0x52, 0x65, 
+	0x11, 0x32, 0x6b, 
+	0x05, 0x0d, 0x1c, 
+	0x0e, 0x0c, 0x05, 
+	0x75, 0x61, 0x1a, 
+	0x2e, 0x25, 0x07, 
+	0x6e, 0x5a, 0x13, 
+	0x27, 0x74, 0xa7, 
+	0x2a, 0x6d, 0xa6, 
+	0x2d, 0x6c, 0xa7, 
+	0x21, 0x5a, 0x99, 
+	0x23, 0x53, 0x8c, 
+	0x18, 0x57, 0x77, 
+	0x2b, 0x54, 0x68, 
+	0x2f, 0x4f, 0x6d, 
+	0x0c, 0x34, 0x7f, 
+	0x7c, 0x64, 0x13, 
+	0x54, 0x44, 0x0d, 
+	0x0a, 0x55, 0x89, 
+	0x24, 0x6d, 0xa2, 
+	0x1f, 0x5d, 0x99, 
+	0x1c, 0x53, 0x94, 
+	0x16, 0x5a, 0x73, 
+	0x13, 0x5c, 0x6a, 
+	0x23, 0x4d, 0x6a, 
+	0x20, 0x38, 0x6a, 
+	0x02, 0x26, 0x70, 
+	0x53, 0x44, 0x13, 
+	0x76, 0x5f, 0x11, 
+	0x5d, 0x4d, 0x15, 
+	0x07, 0x4d, 0x84, 
+	0x17, 0x62, 0x84, 
+	0x15, 0x60, 0x7d, 
+	0x13, 0x63, 0x71, 
+	0x11, 0x5e, 0x6c, 
+	0x0b, 0x52, 0x6d, 
+	0x13, 0x43, 0x64, 
+	0x17, 0x33, 0x6d, 
+	0x1f, 0x1a, 0x09, 
+	0x32, 0x2a, 0x0c, 
+	0x6e, 0x5b, 0x18, 
+	0x6a, 0x55, 0x0d, 
+	0x44, 0x38, 0x0e, 
+	0x17, 0x55, 0x92, 
+	0x16, 0x50, 0x8f, 
+	0x0f, 0x51, 0x7a, 
+	0x0a, 0x4a, 0x75, 
+	0x05, 0x43, 0x6f, 
+	0x02, 0x32, 0x6e, 
+	0x05, 0x2d, 0x77, 
+	0x3d, 0x32, 0x0e, 
+	0x4d, 0x3f, 0x0f, 
+	0x67, 0x55, 0x14, 
+	0x79, 0x62, 0x13, 
+	0x54, 0x45, 0x12, 
+	0x02, 0x38, 0x77, 
+	0x08, 0x3c, 0x7e, 
+	0x03, 0x32, 0x76, 
+	0x02, 0x2c, 0x72, 
+	0x7e, 0x68, 0x19, 
+	0x50, 0x41, 0x0f, 
+	0x2d, 0x25, 0x09
+
+};
+unsigned char item_disk[] = { 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x03, 0x04, 0x05, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 
+	0x06, 0x07, 0x08, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x0a, 0x0b, 0x0c, 
+	0x0d, 0x0e, 0x00, 0x00, 0x00, 0x0f, 0x07, 0x08, 0x10, 
+	0x11, 0x07, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x05, 0x12, 0x13, 0x14, 0x14, 0x15, 0x16, 0x0e, 0x00, 
+	0x00, 0x17, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x13, 0x19, 0x1a, 
+	0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x00, 0x00, 0x20, 0x21, 
+	0x22, 0x18, 0x18, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x05, 0x13, 0x1b, 0x23, 0x24, 0x25, 0x24, 0x1d, 
+	0x26, 0x27, 0x28, 0x00, 0x00, 0x20, 0x29, 0x29, 0x20, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x26, 0x2b, 
+	0x2c, 0x23, 0x25, 0x1c, 0x2d, 0x2e, 0x26, 0x2f, 0x30, 
+	0x31, 0x05, 0x00, 0x32, 0x29, 0x29, 0x06, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x33, 0x2f, 0x1d, 0x34, 0x1c, 0x34, 
+	0x1d, 0x35, 0x36, 0x14, 0x2b, 0x0b, 0x30, 0x31, 0x00, 
+	0x00, 0x37, 0x22, 0x38, 0x32, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 
+	0x39, 0x1e, 0x3a, 0x3a, 0x35, 0x3a, 0x35, 0x15, 0x3a, 
+	0x35, 0x15, 0x1e, 0x3b, 0x3c, 0x00, 0x3d, 0x3e, 0x3f, 
+	0x3f, 0x40, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x42, 0x43, 0x42, 0x3b, 0x44, 
+	0x1e, 0x45, 0x45, 0x3a, 0x15, 0x34, 0x46, 0x35, 0x45, 
+	0x3c, 0x05, 0x47, 0x48, 0x40, 0x49, 0x3f, 0x3f, 0x3f, 
+	0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x44, 0x45, 0x45, 
+	0x46, 0x50, 0x46, 0x46, 0x44, 0x3c, 0x05, 0x00, 0x51, 
+	0x52, 0x53, 0x54, 0x37, 0x55, 0x56, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x57, 
+	0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x45, 0x5d, 0x5d, 0x5e, 
+	0x5f, 0x3c, 0x05, 0x60, 0x61, 0x00, 0x62, 0x40, 0x63, 
+	0x64, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2a, 0x66, 0x67, 
+	0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x3f, 0x05, 0x6e, 
+	0x6e, 0x6e, 0x00, 0x6f, 0x49, 0x70, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x71, 0x72, 0x73, 
+	0x74, 0x71, 0x75, 0x00, 0x00, 0x76, 0x77, 0x78, 0x79, 
+	0x79, 0x7a, 0x55, 0x00, 0x6e, 0x6e, 0x60, 0x00, 0x6f, 
+	0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 
+	0x00, 0x00, 0x83, 0x84, 0x85, 0x85, 0x86, 0x49, 0x00, 
+	0x6e, 0x6e, 0x61, 0x87, 0x88, 0x32, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x89, 0x8a, 0x8b, 0x8c, 
+	0x8d, 0x8e, 0x80, 0x8f, 0x90, 0x91, 0x00, 0x00, 0x92, 
+	0x93, 0x94, 0x95, 0x96, 0x00, 0x6e, 0x60, 0x00, 0x97, 
+	0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x99, 0x7b, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 
+	0xa1, 0xa2, 0xa3, 0x00, 0x62, 0xa4, 0xa5, 0xa6, 0x6f, 
+	0x00, 0x6e, 0x61, 0xa7, 0xa8, 0x56, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x7b, 0xa9, 0xaa, 0xab, 
+	0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3, 0x00, 
+	0xb4, 0xb5, 0xa6, 0xb6, 0x63, 0x00, 0x60, 0x00, 0xb7, 
+	0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x7b, 0xb9, 0xa9, 0xba, 0xbb, 0xbc, 0xbd, 0xa0, 
+	0xbe, 0xbf, 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0x21, 0xb6, 
+	0x63, 0x00, 0x61, 0xc5, 0xc6, 0x56, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x73, 0x73, 
+	0xc8, 0xc9, 0x9f, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 
+	0x00, 0x2a, 0x47, 0x38, 0x3d, 0xd0, 0x00, 0x00, 0xd1, 
+	0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0xd2, 0xd3, 0x7f, 0x80, 0xd4, 0x8f, 0xd5, 
+	0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0x00, 0xc3, 0xdb, 0xc4, 
+	0x38, 0xdc, 0x00, 0xc5, 0xdd, 0x56, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xde, 
+	0x7f, 0xaf, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 
+	0x00, 0x00, 0xe6, 0xe7, 0xe8, 0x88, 0xe9, 0x00, 0xea, 
+	0x56, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0xeb, 0xec, 0x82, 0xed, 
+	0xee, 0xef, 0xf0, 0xf1, 0x00, 0x00, 0x00, 0x00, 0xf2, 
+	0xf3, 0xf4, 0xf5, 0x00, 0xf6, 0x06, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0xf7, 0xf8, 0xf9, 0xfa, 0xfa, 0xda, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0xfb, 0x06, 
+	0xfc, 0xfd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 
+};
+
+// Skip
+
+unsigned char item_skip_colors[] = { 
+	0x04, 0x02, 0x04, 
+	0xa4, 0xa6, 0xa4, 
+	0x1c, 0x1a, 0x1c, 
+	0x1c, 0x1e, 0x1c, 
+	0x14, 0x16, 0x14, 
+	0x9c, 0x9a, 0x9c, 
+	0x94, 0x92, 0x94, 
+	0x9c, 0x9e, 0x9c, 
+	0x94, 0x96, 0x94, 
+	0x8c, 0x8e, 0x8c, 
+	0xdc, 0xda, 0xdc, 
+	0xac, 0xae, 0xac, 
+	0xac, 0xfe, 0x04, 
+	0xbc, 0xba, 0xbc, 
+	0x3c, 0x3a, 0x3c, 
+	0x9c, 0xe6, 0x0c, 
+	0x8c, 0x8a, 0x8c, 
+	0x74, 0xae, 0x04, 
+	0x8c, 0xce, 0x0c, 
+	0x9c, 0xe2, 0x0c, 
+	0x84, 0x86, 0x84, 
+	0xfc, 0xd6, 0x8c, 
+	0xfc, 0xd2, 0x8c, 
+	0x74, 0xaa, 0x0c, 
+	0x8c, 0xc6, 0x0c, 
+	0x9c, 0xde, 0x0c, 
+	0xa4, 0xa2, 0xa4, 
+	0x7c, 0x7e, 0x7c, 
+	0x64, 0x66, 0x64, 
+	0xf4, 0xb2, 0x1c, 
+	0xf4, 0xba, 0x44, 
+	0x74, 0xa6, 0x0c, 
+	0x94, 0xd6, 0x14, 
+	0xfc, 0xb2, 0x24, 
+	0xf4, 0xaa, 0x1c, 
+	0xf4, 0xa6, 0x14, 
+	0x6c, 0x9e, 0x14, 
+	0x84, 0xc2, 0x04, 
+	0x94, 0xce, 0x14, 
+	0x94, 0xd2, 0x14, 
+	0xcc, 0xca, 0xcc, 
+	0xfc, 0xb6, 0x24, 
+	0xec, 0xa6, 0x14, 
+	0xdc, 0x92, 0x04, 
+	0xec, 0xae, 0x3c, 
+	0x74, 0xa2, 0x0c, 
+	0x84, 0xba, 0x14, 
+	0x8c, 0xca, 0x14, 
+	0xa4, 0xfa, 0x04, 
+	0xf4, 0xae, 0x1c, 
+	0xec, 0x9e, 0x0c, 
+	0xdc, 0x96, 0x04, 
+	0xec, 0xaa, 0x3c, 
+	0xa4, 0xee, 0x04, 
+	0x74, 0x72, 0x74, 
+	0xc4, 0xc2, 0xc4, 
+	0xe4, 0x9e, 0x0c, 
+	0xdc, 0x8e, 0x04, 
+	0xd4, 0x8a, 0x04, 
+	0xcc, 0x82, 0x04, 
+	0xdc, 0xa2, 0x3c, 
+	0xfc, 0xce, 0x84, 
+	0x94, 0xda, 0x04, 
+	0x5c, 0x5a, 0x5c, 
+	0xec, 0xa2, 0x0c, 
+	0xe4, 0x9a, 0x04, 
+	0xcc, 0x7e, 0x04, 
+	0xc4, 0x7a, 0x04, 
+	0xd4, 0x92, 0x24, 
+	0x24, 0x22, 0x24, 
+	0x2c, 0x2a, 0x2c, 
+	0xb4, 0xb2, 0xb4, 
+	0xd4, 0x8e, 0x04, 
+	0xbc, 0x76, 0x04, 
+	0xf4, 0xc6, 0x7c, 
+	0x54, 0x56, 0x54, 
+	0x2c, 0x2e, 0x2c, 
+	0x34, 0x32, 0x34, 
+	0xd4, 0x86, 0x04, 
+	0xc4, 0x7e, 0x04, 
+	0xbc, 0x72, 0x04, 
+	0xec, 0xbe, 0x6c, 
+	0x64, 0x9a, 0x04, 
+	0x6c, 0x6e, 0x6c, 
+	0xac, 0xaa, 0xac, 
+	0xcc, 0x86, 0x04, 
+	0xe4, 0xb2, 0x5c, 
+	0x4c, 0x4a, 0x4c, 
+	0xdc, 0xa6, 0x4c, 
+	0x6c, 0x6a, 0x6c, 
+	0x5c, 0x5e, 0x5c, 
+	0x0c, 0x0e, 0x0c, 
+	0x84, 0x82, 0x84, 
+	0x14, 0x12, 0x14, 
+	0x64, 0x62, 0x64, 
+	0x34, 0x36, 0x34, 
+	0x74, 0x76, 0x74, 
+	0x7c, 0x7a, 0x7c
+
+};
+unsigned char item_skip[] = { 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 
+	0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x04, 0x02, 0x04, 0x05, 0x06, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x02, 0x02, 0x07, 0x08, 0x07, 0x09, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x0a, 0x0b, 0x04, 0x05, 0x07, 
+	0x05, 0x05, 0x07, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x00, 0x00, 
+	0x04, 0x0d, 0x04, 0x0e, 0x0e, 0x07, 0x05, 0x07, 0x05, 
+	0x07, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x0f, 0x0f, 0x0c, 0x0c, 0x00, 0x00, 0x04, 0x0b, 
+	0x06, 0x0e, 0x0e, 0x08, 0x05, 0x05, 0x07, 0x08, 0x10, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x12, 0x13, 
+	0x13, 0x0c, 0x0c, 0x00, 0x00, 0x07, 0x01, 0x09, 0x0e, 
+	0x0e, 0x09, 0x09, 0x06, 0x14, 0x02, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x15, 0x16, 0x00, 0x00, 0x17, 0x18, 0x19, 0x19, 0x0c, 
+	0x0c, 0x00, 0x00, 0x07, 0x1a, 0x14, 0x0e, 0x0e, 0x1b, 
+	0x1c, 0x02, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x1d, 0x1e, 0x16, 0x16, 
+	0x00, 0x00, 0x1f, 0x18, 0x20, 0x20, 0x0c, 0x0c, 0x00, 
+	0x00, 0x08, 0x05, 0x14, 0x0e, 0x0e, 0x04, 0x03, 0x02, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x21, 0x22, 0x23, 0x1e, 0x15, 0x16, 0x00, 0x00, 
+	0x24, 0x25, 0x26, 0x27, 0x0c, 0x0c, 0x00, 0x06, 0x08, 
+	0x05, 0x10, 0x04, 0x28, 0x04, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x1d, 0x23, 
+	0x2a, 0x2b, 0x2c, 0x16, 0x15, 0x00, 0x00, 0x2d, 0x2e, 
+	0x2f, 0x30, 0x00, 0x1b, 0x14, 0x06, 0x07, 0x02, 0x0a, 
+	0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x31, 0x22, 0x2a, 0x32, 0x33, 0x2b, 0x2b, 
+	0x34, 0x15, 0x16, 0x00, 0x00, 0x2f, 0x35, 0x00, 0x36, 
+	0x1b, 0x10, 0x09, 0x02, 0x04, 0x37, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x2a, 
+	0x32, 0x38, 0x2b, 0x2b, 0x39, 0x3a, 0x3b, 0x3c, 0x16, 
+	0x3d, 0x00, 0x3e, 0x00, 0x3f, 0x36, 0x1b, 0x09, 0x02, 
+	0x04, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x2a, 0x40, 0x41, 0x41, 0x2b, 0x39, 
+	0x3a, 0x3b, 0x42, 0x43, 0x44, 0x3d, 0x00, 0x25, 0x00, 
+	0x45, 0x46, 0x1c, 0x10, 0x04, 0x47, 0x04, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x33, 0x33, 0x2b, 0x39, 0x48, 0x3b, 0x42, 0x49, 
+	0x42, 0x4a, 0x00, 0x11, 0x00, 0x4b, 0x1c, 0x4c, 0x4d, 
+	0x04, 0x0b, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x39, 
+	0x48, 0x4e, 0x4f, 0x42, 0x50, 0x43, 0x51, 0x00, 0x52, 
+	0x00, 0x4b, 0x1c, 0x53, 0x10, 0x02, 0x04, 0x54, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x55, 0x4f, 0x43, 
+	0x50, 0x50, 0x56, 0x00, 0x00, 0x57, 0x4b, 0x1c, 0x36, 
+	0x10, 0x04, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x4f, 0x50, 0x50, 0x58, 0x00, 
+	0x4c, 0x57, 0x3f, 0x59, 0x1b, 0x08, 0x04, 0x54, 0x04, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5a, 0x5b, 
+	0x00, 0x00, 0x50, 0x44, 0x00, 0x03, 0x45, 0x57, 0x1c, 
+	0x5c, 0x08, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x5c, 0x1b, 0x5d, 0x5a, 0x00, 0x00, 
+	0x4b, 0x3f, 0x57, 0x46, 0x4d, 0x5a, 0x06, 0x04, 0x02, 
+	0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x5b, 0x53, 0x1c, 0x5e, 0x5e, 0x1c, 0x59, 0x53, 
+	0x5a, 0x5f, 0x0e, 0x04, 0x02, 0x02, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4b, 
+	0x53, 0x53, 0x53, 0x60, 0x60, 0x1b, 0x5c, 0x5c, 0x02, 
+	0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x60, 0x61, 
+	0x1b, 0x1b, 0x09, 0x09, 0x02, 0x01, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x5e, 0x1b, 0x08, 0x05, 0x06, 
+	0x04, 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x53, 0x06, 0x08, 0x02, 0x02, 0x02, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x53, 0x02, 0x09, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x09, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 
+};
+
+// Sound
+
+unsigned char item_soundOff_colors[] = { 
+	0x04, 0x02, 0x04, 
+	0xac, 0xae, 0xac, 
+	0xe4, 0xe2, 0xdc, 
+	0xe4, 0xde, 0xdc, 
+	0xac, 0xaa, 0xa4, 
+	0xf4, 0xee, 0xec, 
+	0xf4, 0xf6, 0xf4, 
+	0xec, 0xee, 0xec, 
+	0xdc, 0xda, 0xd4, 
+	0xa4, 0xa6, 0xa4, 
+	0xf4, 0xf2, 0xec, 
+	0xdc, 0xd6, 0xd4, 
+	0x9c, 0x9e, 0x9c, 
+	0xac, 0xaa, 0x9c, 
+	0xd4, 0xd2, 0xcc, 
+	0xdc, 0xde, 0xd4, 
+	0xcc, 0xce, 0xc4, 
+	0x9c, 0x9a, 0x94, 
+	0x74, 0x72, 0x5c, 
+	0xcc, 0xca, 0xc4, 
+	0xc4, 0xc6, 0xbc, 
+	0x94, 0x96, 0x94, 
+	0xec, 0xea, 0xe4, 
+	0x6c, 0x6a, 0x54, 
+	0xa4, 0xa2, 0x94, 
+	0xcc, 0xc6, 0xbc, 
+	0xc4, 0xc2, 0xbc, 
+	0xbc, 0xbe, 0xb4, 
+	0x94, 0x92, 0x8c, 
+	0x6c, 0x66, 0x54, 
+	0x64, 0x62, 0x54, 
+	0x6c, 0x62, 0x4c, 
+	0x9c, 0x9e, 0x8c, 
+	0xc4, 0xc2, 0xb4, 
+	0xbc, 0xba, 0xb4, 
+	0x8c, 0x8a, 0x84, 
+	0xd4, 0xd6, 0xcc, 
+	0x64, 0x5e, 0x4c, 
+	0xb4, 0xb6, 0xac, 
+	0x9c, 0x9a, 0x8c, 
+	0xbc, 0xb6, 0xac, 
+	0x54, 0x56, 0x44, 
+	0x5c, 0x56, 0x44, 
+	0xb4, 0xb2, 0xac, 
+	0x5c, 0x5a, 0x44, 
+	0x44, 0x46, 0x44, 
+	0x54, 0x52, 0x3c, 
+	0xbc, 0xba, 0xac, 
+	0x5c, 0x5a, 0x4c, 
+	0xac, 0xae, 0xa4, 
+	0xb4, 0xb2, 0xa4, 
+	0x4c, 0x4a, 0x4c, 
+	0x1c, 0x1a, 0x14, 
+	0x44, 0x42, 0x34, 
+	0xa4, 0xa2, 0x9c, 
+	0x54, 0x52, 0x44, 
+	0xb4, 0xb6, 0xb4, 
+	0x2c, 0x2e, 0x2c, 
+	0x2c, 0x2a, 0x24, 
+	0x84, 0x82, 0x7c, 
+	0x4c, 0x4a, 0x3c, 
+	0x54, 0x4e, 0x3c, 
+	0xb4, 0xae, 0xa4, 
+	0x74, 0x76, 0x74, 
+	0x3c, 0x3a, 0x2c, 
+	0xac, 0xa6, 0x9c, 
+	0x9c, 0x9e, 0x94, 
+	0x94, 0x92, 0x94, 
+	0x64, 0x5e, 0x54, 
+	0x4c, 0x4e, 0x44, 
+	0x6c, 0x66, 0x5c, 
+	0x94, 0x92, 0x84, 
+	0x6c, 0x6a, 0x64, 
+	0x64, 0x66, 0x64, 
+	0x64, 0x62, 0x5c, 
+	0x8c, 0x8a, 0x7c, 
+	0x84, 0x86, 0x84, 
+	0x74, 0x72, 0x6c, 
+	0x6c, 0x6e, 0x6c, 
+	0x9c, 0x96, 0x8c, 
+	0x84, 0x82, 0x74, 
+	0x7c, 0x7a, 0x7c, 
+	0x6c, 0x6e, 0x64, 
+	0xa4, 0xa6, 0x9c, 
+	0x84, 0x86, 0x7c, 
+	0x7c, 0x7a, 0x6c, 
+	0x5c, 0x5a, 0x54, 
+	0xa4, 0x9e, 0x94, 
+	0x74, 0x72, 0x64, 
+	0x54, 0x56, 0x54, 
+	0x3c, 0x3e, 0x3c, 
+	0x84, 0x7e, 0x7c, 
+	0xfc, 0x6a, 0x6c, 
+	0xbc, 0x02, 0x04, 
+	0xfc, 0x02, 0x04, 
+	0x94, 0x96, 0x8c, 
+	0x94, 0x8e, 0x84, 
+	0x8c, 0x8e, 0x84, 
+	0x54, 0x56, 0x4c, 
+	0x74, 0x76, 0x6c, 
+	0x34, 0x36, 0x2c
+
+};
+unsigned char item_soundOff[] = { 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x05, 0x06, 0x07, 0x08, 0x09, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x0a, 0x0a, 0x0a, 0x02, 0x02, 0x0b, 0x0c, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x06, 0x0d, 0x0e, 
+	0x0f, 0x0b, 0x02, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x0a, 0x07, 0x12, 0x12, 0x0d, 0x10, 0x10, 0x0e, 
+	0x13, 0x14, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x05, 0x17, 
+	0x10, 0x17, 0x17, 0x18, 0x08, 0x13, 0x19, 0x1a, 0x1b, 
+	0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x08, 0x17, 0x1d, 0x19, 0x14, 0x1e, 
+	0x1f, 0x20, 0x1a, 0x1a, 0x21, 0x22, 0x22, 0x23, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x13, 
+	0x25, 0x26, 0x25, 0x25, 0x1b, 0x1a, 0x25, 0x25, 0x27, 
+	0x22, 0x22, 0x28, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x2a, 0x2b, 0x2b, 
+	0x25, 0x25, 0x1b, 0x1b, 0x2c, 0x2c, 0x28, 0x26, 0x2b, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 
+	0x2d, 0x00, 0x15, 0x2e, 0x29, 0x2b, 0x2f, 0x30, 0x2c, 
+	0x22, 0x2a, 0x28, 0x31, 0x32, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x0c, 0x33, 0x00, 0x34, 0x35, 0x15, 
+	0x36, 0x2a, 0x2a, 0x22, 0x26, 0x2a, 0x37, 0x2b, 0x32, 
+	0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x2d, 
+	0x00, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x31, 0x32, 0x2a, 
+	0x2a, 0x26, 0x2e, 0x31, 0x3e, 0x18, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x1c, 0x00, 0x3f, 0x33, 0x40, 0x35, 
+	0x1c, 0x36, 0x29, 0x2a, 0x26, 0x32, 0x37, 0x37, 0x41, 
+	0x04, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 
+	0x00, 0x3f, 0x44, 0x45, 0x46, 0x3c, 0x2e, 0x3e, 0x2b, 
+	0x37, 0x37, 0x3e, 0x3d, 0x31, 0x42, 0x47, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x48, 0x49, 0x4a, 
+	0x1c, 0x11, 0x3b, 0x37, 0x37, 0x32, 0x2b, 0x3d, 0x3c, 
+	0x41, 0x18, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x4c, 0x00, 0x48, 0x4d, 0x4e, 0x1c, 0x42, 0x04, 0x31, 
+	0x4b, 0x3d, 0x3d, 0x31, 0x3c, 0x4f, 0x11, 0x50, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x49, 0x52, 
+	0x3b, 0x1c, 0x53, 0x0d, 0x3e, 0x3e, 0x31, 0x54, 0x3c, 
+	0x35, 0x27, 0x27, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x4a, 0x00, 0x56, 0x49, 0x55, 0x1c, 0x36, 0x0d, 
+	0x04, 0x31, 0x0d, 0x0d, 0x57, 0x55, 0x18, 0x47, 0x58, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x59, 0x00, 0x5a, 
+	0x4a, 0x5b, 0x1c, 0x11, 0x53, 0x04, 0x41, 0x53, 0x18, 
+	0x18, 0x27, 0x57, 0x54, 0x46, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x00, 
+	0x00, 0x00, 0x5c, 0x00, 0x00, 0x5a, 0x4d, 0x23, 0x57, 
+	0x36, 0x0d, 0x18, 0x57, 0x18, 0x57, 0x1c, 0x47, 0x4b, 
+	0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x5d, 0x5e, 0x5c, 0x00, 0x5d, 0x5e, 0x5c, 
+	0x00, 0x00, 0x00, 0x46, 0x5f, 0x18, 0x18, 0x36, 0x57, 
+	0x42, 0x27, 0x60, 0x47, 0x4b, 0x44, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 
+	0x5e, 0x5d, 0x5e, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x52, 0x53, 0x18, 0x57, 0x27, 0x47, 0x61, 0x50, 
+	0x50, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x5d, 0x5e, 0x5c, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 
+	0x27, 0x20, 0x60, 0x50, 0x60, 0x50, 0x62, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x5d, 0x5e, 0x5e, 0x5e, 0x5c, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0x61, 0x47, 
+	0x50, 0x50, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x5d, 0x5e, 0x5c, 0x00, 0x5d, 
+	0x5e, 0x5c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x3c, 0x55, 0x63, 0x3c, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x5c, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x3c, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 
+};
+
+unsigned char item_soundOn_colors[] = { 
+	0x04, 0x02, 0x04, 
+	0xac, 0xae, 0xac, 
+	0xe4, 0xe2, 0xdc, 
+	0xe4, 0xde, 0xdc, 
+	0xac, 0xaa, 0xa4, 
+	0xf4, 0xee, 0xec, 
+	0xf4, 0xf6, 0xf4, 
+	0xec, 0xee, 0xec, 
+	0xdc, 0xda, 0xd4, 
+	0xa4, 0xa6, 0xa4, 
+	0xf4, 0xf2, 0xec, 
+	0xdc, 0xd6, 0xd4, 
+	0x9c, 0x9e, 0x9c, 
+	0xac, 0xaa, 0x9c, 
+	0xd4, 0xd2, 0xcc, 
+	0xdc, 0xde, 0xd4, 
+	0xcc, 0xce, 0xc4, 
+	0x9c, 0x9a, 0x94, 
+	0x74, 0x72, 0x5c, 
+	0xcc, 0xca, 0xc4, 
+	0xc4, 0xc6, 0xbc, 
+	0x94, 0x96, 0x94, 
+	0xec, 0xea, 0xe4, 
+	0x6c, 0x6a, 0x54, 
+	0xa4, 0xa2, 0x94, 
+	0xcc, 0xc6, 0xbc, 
+	0xc4, 0xc2, 0xbc, 
+	0xbc, 0xbe, 0xb4, 
+	0x94, 0x92, 0x8c, 
+	0x6c, 0x66, 0x54, 
+	0x64, 0x62, 0x54, 
+	0x6c, 0x62, 0x4c, 
+	0x9c, 0x9e, 0x8c, 
+	0xc4, 0xc2, 0xb4, 
+	0xbc, 0xba, 0xb4, 
+	0x8c, 0x8a, 0x84, 
+	0xd4, 0xd6, 0xcc, 
+	0x64, 0x5e, 0x4c, 
+	0xb4, 0xb6, 0xac, 
+	0x9c, 0x9a, 0x8c, 
+	0xbc, 0xb6, 0xac, 
+	0x54, 0x56, 0x44, 
+	0x5c, 0x56, 0x44, 
+	0xb4, 0xb2, 0xac, 
+	0x5c, 0x5a, 0x44, 
+	0x44, 0x46, 0x44, 
+	0x54, 0x52, 0x3c, 
+	0xbc, 0xba, 0xac, 
+	0x5c, 0x5a, 0x4c, 
+	0xac, 0xae, 0xa4, 
+	0xb4, 0xb2, 0xa4, 
+	0x4c, 0x4a, 0x4c, 
+	0x1c, 0x1a, 0x14, 
+	0x44, 0x42, 0x34, 
+	0xa4, 0xa2, 0x9c, 
+	0x54, 0x52, 0x44, 
+	0xb4, 0xb6, 0xb4, 
+	0x2c, 0x2e, 0x2c, 
+	0x2c, 0x2a, 0x24, 
+	0x84, 0x82, 0x7c, 
+	0x4c, 0x4a, 0x3c, 
+	0x54, 0x4e, 0x3c, 
+	0xb4, 0xae, 0xa4, 
+	0x74, 0x76, 0x74, 
+	0x3c, 0x3a, 0x2c, 
+	0xac, 0xa6, 0x9c, 
+	0x9c, 0x9e, 0x94, 
+	0x94, 0x92, 0x94, 
+	0x64, 0x5e, 0x54, 
+	0x4c, 0x4e, 0x44, 
+	0x6c, 0x66, 0x5c, 
+	0x94, 0x92, 0x84, 
+	0x6c, 0x6a, 0x64, 
+	0x64, 0x66, 0x64, 
+	0x64, 0x62, 0x5c, 
+	0x8c, 0x8a, 0x7c, 
+	0x84, 0x86, 0x84, 
+	0x74, 0x72, 0x6c, 
+	0x6c, 0x6e, 0x6c, 
+	0x9c, 0x96, 0x8c, 
+	0x84, 0x82, 0x74, 
+	0x7c, 0x7a, 0x74, 
+	0x6c, 0x6e, 0x64, 
+	0xa4, 0xa6, 0x9c, 
+	0x84, 0x86, 0x7c, 
+	0x7c, 0x7a, 0x6c, 
+	0x64, 0x62, 0x64, 
+	0x5c, 0x5a, 0x54, 
+	0xa4, 0x9e, 0x94, 
+	0x74, 0x72, 0x64, 
+	0x54, 0x56, 0x54, 
+	0x3c, 0x3e, 0x3c, 
+	0x84, 0x7e, 0x7c, 
+	0xf4, 0xf2, 0xf4, 
+	0xac, 0xaa, 0xac, 
+	0x94, 0x96, 0x8c, 
+	0x94, 0x8e, 0x84, 
+	0x8c, 0x8e, 0x84, 
+	0x34, 0x32, 0x34, 
+	0x54, 0x56, 0x4c, 
+	0x74, 0x76, 0x6c, 
+	0x34, 0x36, 0x2c
+
+};
+unsigned char item_soundOn[] = { 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 
+	0x03, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x05, 0x06, 0x07, 0x08, 0x09, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x0a, 0x0a, 0x0a, 0x02, 0x02, 0x0b, 0x0c, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x06, 0x0d, 0x0e, 
+	0x0f, 0x0b, 0x02, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x0a, 0x07, 0x12, 0x12, 0x0d, 0x10, 0x10, 0x0e, 
+	0x13, 0x14, 0x15, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x05, 0x17, 
+	0x10, 0x17, 0x17, 0x18, 0x08, 0x13, 0x19, 0x1a, 0x1b, 
+	0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x03, 0x08, 0x17, 0x1d, 0x19, 0x14, 0x1e, 
+	0x1f, 0x20, 0x1a, 0x1a, 0x21, 0x22, 0x22, 0x23, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x13, 
+	0x25, 0x26, 0x25, 0x25, 0x1b, 0x1a, 0x25, 0x25, 0x27, 
+	0x22, 0x22, 0x28, 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x2a, 0x2b, 0x2b, 
+	0x25, 0x25, 0x1b, 0x1b, 0x2c, 0x2c, 0x28, 0x26, 0x2b, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 
+	0x2d, 0x00, 0x15, 0x2e, 0x29, 0x2b, 0x2f, 0x30, 0x2c, 
+	0x22, 0x2a, 0x28, 0x31, 0x32, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x0c, 0x33, 0x00, 0x34, 0x35, 0x15, 
+	0x36, 0x2a, 0x2a, 0x22, 0x26, 0x2a, 0x37, 0x2b, 0x32, 
+	0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x2d, 
+	0x00, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x31, 0x32, 0x2a, 
+	0x2a, 0x26, 0x2e, 0x31, 0x3e, 0x18, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x1c, 0x00, 0x3f, 0x33, 0x40, 0x35, 
+	0x1c, 0x36, 0x29, 0x2a, 0x26, 0x32, 0x37, 0x37, 0x41, 
+	0x04, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x43, 
+	0x00, 0x3f, 0x44, 0x45, 0x46, 0x3c, 0x2e, 0x3e, 0x2b, 
+	0x37, 0x37, 0x3e, 0x3d, 0x31, 0x42, 0x47, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x48, 0x49, 0x4a, 
+	0x1c, 0x11, 0x3b, 0x37, 0x37, 0x32, 0x2b, 0x3d, 0x3c, 
+	0x41, 0x18, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x4c, 0x00, 0x48, 0x4d, 0x4e, 0x1c, 0x42, 0x04, 0x31, 
+	0x4b, 0x3d, 0x3d, 0x31, 0x3c, 0x4f, 0x11, 0x50, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x51, 0x00, 0x49, 0x52, 
+	0x3b, 0x1c, 0x53, 0x0d, 0x3e, 0x3e, 0x31, 0x54, 0x3c, 
+	0x35, 0x27, 0x27, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x56, 0x00, 0x57, 0x49, 0x55, 0x1c, 0x36, 0x0d, 
+	0x04, 0x31, 0x0d, 0x0d, 0x58, 0x55, 0x18, 0x47, 0x59, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5a, 0x00, 0x5b, 
+	0x4a, 0x5c, 0x1c, 0x11, 0x53, 0x04, 0x41, 0x53, 0x18, 
+	0x18, 0x27, 0x58, 0x54, 0x46, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 
+	0x43, 0x5a, 0x5b, 0x00, 0x00, 0x5b, 0x4d, 0x23, 0x58, 
+	0x36, 0x0d, 0x18, 0x58, 0x18, 0x58, 0x1c, 0x47, 0x4b, 
+	0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x4c, 0x5d, 0x5e, 0x4e, 0x5b, 0x00, 
+	0x00, 0x00, 0x00, 0x46, 0x5f, 0x18, 0x18, 0x36, 0x58, 
+	0x42, 0x27, 0x60, 0x47, 0x4b, 0x44, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 
+	0x5e, 0x5e, 0x4e, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x52, 0x53, 0x18, 0x58, 0x27, 0x47, 0x61, 0x50, 
+	0x50, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x5a, 0x4e, 0x4e, 0x62, 0x62, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 
+	0x27, 0x20, 0x60, 0x50, 0x60, 0x50, 0x63, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x5b, 0x62, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0x61, 0x47, 
+	0x50, 0x50, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x3c, 0x55, 0x64, 0x3c, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x3c, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 
+};
+
+// Mode
+
+unsigned char item_monkeyLandscape_colors[] = { 
+	0x00, 0x00, 0x00, 
+	0x0e, 0x16, 0x00, 
+	0x04, 0x02, 0x04, 
+	0x3c, 0x3a, 0x3c, 
+	0x9c, 0x9a, 0x9c, 
+	0x6c, 0x6a, 0x6c, 
+	0x1c, 0x0a, 0x0c, 
+	0x34, 0x36, 0x34, 
+	0x9c, 0x9e, 0x9c, 
+	0xb4, 0xb2, 0xb4, 
+	0x24, 0x06, 0x04, 
+	0x34, 0x32, 0x34, 
+	0xa4, 0xa6, 0xa4, 
+	0x64, 0x66, 0x64, 
+	0x2c, 0x2e, 0x2c, 
+	0x1c, 0x1a, 0x1c, 
+	0x6c, 0x6e, 0x6c, 
+	0x94, 0x92, 0x94, 
+	0x74, 0x72, 0x74, 
+	0x94, 0x96, 0x94, 
+	0x8c, 0x8e, 0x8c, 
+	0x8c, 0x8a, 0x8c, 
+	0x24, 0x26, 0x24, 
+	0x7c, 0x7e, 0x7c, 
+	0x74, 0x76, 0x74, 
+	0xa4, 0xa2, 0xa4, 
+	0x1c, 0x1e, 0x1c, 
+	0x0c, 0x0a, 0x0c, 
+	0xac, 0xae, 0xac, 
+	0xbc, 0xbe, 0xbc, 
+	0xdc, 0xde, 0xdc, 
+	0xfc, 0xfa, 0xfc, 
+	0xec, 0xee, 0xec, 
+	0xcc, 0xce, 0xcc, 
+	0x44, 0x46, 0x44, 
+	0x3c, 0x3e, 0x3c, 
+	0x4c, 0x4e, 0x4c, 
+	0x1c, 0x16, 0x1c, 
+	0xbc, 0xba, 0xbc, 
+	0xd4, 0xd6, 0xd4, 
+	0xf4, 0xf2, 0xf4, 
+	0x2c, 0x5e, 0x7c, 
+	0x2c, 0x7e, 0xb4, 
+	0x5c, 0x5a, 0x5c, 
+	0x14, 0x16, 0x14, 
+	0x0c, 0x06, 0x0c, 
+	0x04, 0x06, 0x04, 
+	0xc4, 0xc2, 0xc4, 
+	0xe4, 0xe6, 0xe4, 
+	0xac, 0xaa, 0xac, 
+	0xe4, 0xe2, 0xe4, 
+	0x5c, 0x5e, 0x5c, 
+	0x84, 0x82, 0x84, 
+	0x14, 0x0e, 0x04, 
+	0x34, 0x26, 0x14
+
+};
+unsigned char item_monkeyLandscape[] = { 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x02, 0x02, 0x02, 0x02, 0x03, 0x04, 0x05, 0x02, 
+	0x02, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x06, 0x02, 0x02, 0x02, 
+	0x07, 0x08, 0x09, 0x05, 0x02, 0x02, 0x02, 0x00, 0x00, 
+	0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x0a, 0x02, 0x02, 0x0b, 0x04, 0x0c, 0x08, 0x09, 
+	0x0d, 0x02, 0x02, 0x00, 0x00, 0x00, 0x0e, 0x01, 0x01, 
+	0x09, 0x08, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x06, 0x0f, 0x10, 
+	0x11, 0x04, 0x11, 0x12, 0x08, 0x05, 0x02, 0x02, 0x00, 
+	0x00, 0x00, 0x0b, 0x01, 0x01, 0x09, 0x09, 0x13, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x10, 0x11, 0x14, 0x08, 0x09, 0x13, 0x12, 
+	0x08, 0x0d, 0x02, 0x02, 0x00, 0x00, 0x00, 0x0e, 0x01, 
+	0x15, 0x0d, 0x09, 0x09, 0x13, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x14, 0x11, 0x14, 0x14, 
+	0x11, 0x04, 0x10, 0x02, 0x16, 0x17, 0x09, 0x0d, 0x02, 
+	0x00, 0x00, 0x00, 0x03, 0x14, 0x15, 0x0d, 0x13, 0x09, 
+	0x09, 0x13, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x14, 
+	0x04, 0x09, 0x09, 0x09, 0x14, 0x18, 0x19, 0x1a, 0x02, 
+	0x02, 0x1b, 0x05, 0x0d, 0x02, 0x00, 0x00, 0x00, 0x0b, 
+	0x03, 0x15, 0x0d, 0x13, 0x1c, 0x14, 0x14, 0x11, 0x14, 
+	0x04, 0x09, 0x09, 0x1d, 0x1e, 0x1e, 0x1f, 0x20, 0x21, 
+	0x14, 0x22, 0x23, 0x0b, 0x07, 0x0b, 0x22, 0x24, 0x25, 
+	0x02, 0x00, 0x00, 0x00, 0x0b, 0x23, 0x17, 0x01, 0x0d, 
+	0x14, 0x11, 0x14, 0x13, 0x09, 0x26, 0x27, 0x27, 0x1e, 
+	0x1f, 0x1f, 0x1f, 0x1f, 0x28, 0x0c, 0x07, 0x0b, 0x29, 
+	0x2a, 0x0b, 0x2b, 0x0d, 0x2c, 0x02, 0x00, 0x00, 0x00, 
+	0x0e, 0x02, 0x02, 0x01, 0x2d, 0x13, 0x09, 0x09, 0x26, 
+	0x1e, 0x1e, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 
+	0x28, 0x27, 0x08, 0x07, 0x07, 0x0b, 0x07, 0x18, 0x11, 
+	0x0f, 0x02, 0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x02, 
+	0x2e, 0x05, 0x26, 0x27, 0x27, 0x1e, 0x1f, 0x1f, 0x1f, 
+	0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x20, 0x08, 
+	0x0b, 0x0b, 0x0d, 0x2f, 0x13, 0x23, 0x2c, 0x00, 0x00, 
+	0x00, 0x02, 0x02, 0x02, 0x02, 0x02, 0x05, 0x09, 0x09, 
+	0x26, 0x27, 0x1e, 0x1e, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 
+	0x1f, 0x1f, 0x20, 0x30, 0x27, 0x31, 0x1d, 0x08, 0x09, 
+	0x17, 0x07, 0x2c, 0x00, 0x00, 0x00, 0x0e, 0x02, 0x02, 
+	0x2e, 0x0d, 0x11, 0x14, 0x14, 0x13, 0x26, 0x27, 0x27, 
+	0x1e, 0x27, 0x27, 0x32, 0x1f, 0x1f, 0x30, 0x1d, 0x27, 
+	0x1c, 0x33, 0x17, 0x09, 0x34, 0x0b, 0x0b, 0x2c, 0x00, 
+	0x00, 0x00, 0x0b, 0x03, 0x15, 0x33, 0x05, 0x1c, 0x14, 
+	0x11, 0x14, 0x13, 0x09, 0x09, 0x09, 0x09, 0x09, 0x1d, 
+	0x27, 0x27, 0x21, 0x13, 0x17, 0x09, 0x09, 0x09, 0x0c, 
+	0x0d, 0x07, 0x2c, 0x02, 0x00, 0x00, 0x00, 0x0b, 0x23, 
+	0x15, 0x05, 0x09, 0x09, 0x09, 0x1c, 0x11, 0x14, 0x11, 
+	0x14, 0x14, 0x11, 0x13, 0x09, 0x09, 0x09, 0x31, 0x14, 
+	0x17, 0x12, 0x14, 0x14, 0x11, 0x05, 0x0b, 0x25, 0x02, 
+	0x00, 0x00, 0x00, 0x0b, 0x03, 0x15, 0x0d, 0x09, 0x09, 
+	0x13, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x14, 
+	0x11, 0x14, 0x14, 0x14, 0x11, 0x04, 0x09, 0x12, 0x02, 
+	0x03, 0x08, 0x0d, 0x02, 0x02, 0x00, 0x00, 0x00, 0x0e, 
+	0x01, 0x01, 0x11, 0x09, 0x13, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x33, 0x12, 0x11, 
+	0x14, 0x14, 0x08, 0x09, 0x0c, 0x14, 0x08, 0x05, 0x02, 
+	0x02, 0x00, 0x00, 0x00, 0x0b, 0x01, 0x01, 0x01, 0x08, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x35, 0x02, 0x02, 0x0f, 0x10, 0x11, 0x14, 0x08, 
+	0x0c, 0x08, 0x09, 0x0d, 0x02, 0x02, 0x00, 0x00, 0x00, 
+	0x0e, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x36, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x0b, 0x14, 0x14, 0x14, 0x04, 0x09, 0x05, 
+	0x02, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0b, 
+	0x11, 0x08, 0x09, 0x05, 0x02, 0x02, 0x02, 0x00, 0x00, 
+	0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x07, 0x08, 0x05, 
+	0x02, 0x02, 0x02, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02, 
+	0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 
+};
+
+unsigned char item_monkeyPortrait_colors[] = { 
+	0x00, 0x00, 0x00, 
+	0x04, 0x02, 0x04, 
+	0x14, 0x16, 0x14, 
+	0x64, 0x66, 0x64, 
+	0x1c, 0x16, 0x1c, 
+	0x1c, 0x1a, 0x1c, 
+	0x3c, 0x3e, 0x3c, 
+	0x34, 0x36, 0x34, 
+	0x34, 0x32, 0x34, 
+	0x6c, 0x6a, 0x6c, 
+	0xb4, 0xb2, 0xb4, 
+	0x4c, 0x4e, 0x4c, 
+	0x94, 0x92, 0x94, 
+	0x94, 0x96, 0x94, 
+	0x7c, 0x7e, 0x7c, 
+	0x9c, 0x9e, 0x9c, 
+	0x0c, 0x0a, 0x0c, 
+	0x44, 0x46, 0x44, 
+	0x5c, 0x5a, 0x5c, 
+	0x74, 0x76, 0x74, 
+	0xc4, 0xc2, 0xc4, 
+	0x84, 0x82, 0x84, 
+	0x9c, 0x9a, 0x9c, 
+	0x74, 0x72, 0x74, 
+	0x24, 0x26, 0x24, 
+	0xa4, 0xa6, 0xa4, 
+	0x3c, 0x3a, 0x3c, 
+	0x8c, 0x8e, 0x8c, 
+	0x2c, 0x7e, 0xb4, 
+	0xbc, 0xbe, 0xbc, 
+	0x6c, 0x6e, 0x6c, 
+	0x1c, 0x1e, 0x1c, 
+	0x2c, 0x5e, 0x7c, 
+	0xac, 0xaa, 0xac, 
+	0x5c, 0x5e, 0x5c, 
+	0xa4, 0xa2, 0xa4, 
+	0xd4, 0xd6, 0xd4, 
+	0xac, 0xae, 0xac, 
+	0xec, 0xee, 0xec, 
+	0xe4, 0xe6, 0xe4, 
+	0xfc, 0xfa, 0xfc, 
+	0x0e, 0x16, 0x00, 
+	0x1c, 0x0a, 0x0c, 
+	0x24, 0x06, 0x04, 
+	0xcc, 0xce, 0xcc, 
+	0xf4, 0xf2, 0xf4, 
+	0xdc, 0xde, 0xdc, 
+	0xe4, 0xe2, 0xe4, 
+	0x14, 0x0e, 0x04, 
+	0x34, 0x26, 0x14, 
+	0xbc, 0xba, 0xbc, 
+	0x0c, 0x06, 0x0c, 
+	0x04, 0x06, 0x04, 
+	0x8c, 0x8a, 0x8c, 
+	0x2c, 0x2e, 0x2c
+
+};
+unsigned char item_monkeyPortrait[] = { 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x01, 0x03, 0x03, 0x04, 0x02, 0x05, 0x06, 0x07, 
+	0x08, 0x02, 0x04, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x01, 0x01, 0x01, 0x01, 0x03, 0x09, 0x03, 0x0a, 0x09, 
+	0x0b, 0x03, 0x0c, 0x0d, 0x0e, 0x08, 0x07, 0x08, 0x03, 
+	0x09, 0x03, 0x09, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x09, 0x09, 
+	0x0a, 0x0f, 0x0f, 0x0e, 0x10, 0x11, 0x12, 0x13, 0x14, 
+	0x0a, 0x15, 0x03, 0x09, 0x0f, 0x0f, 0x0a, 0x0a, 0x09, 
+	0x09, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x01, 0x01, 0x16, 0x0a, 0x0f, 0x17, 0x17, 0x18, 
+	0x01, 0x08, 0x08, 0x07, 0x03, 0x0f, 0x0a, 0x19, 0x0c, 
+	0x1a, 0x1b, 0x0f, 0x16, 0x0a, 0x0f, 0x01, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x1a, 
+	0x0f, 0x19, 0x0c, 0x0d, 0x01, 0x01, 0x07, 0x1c, 0x08, 
+	0x08, 0x1d, 0x0e, 0x0a, 0x1b, 0x01, 0x19, 0x19, 0x1b, 
+	0x0f, 0x07, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x01, 0x01, 0x01, 0x07, 0x16, 0x16, 0x0a, 
+	0x1e, 0x1f, 0x08, 0x20, 0x07, 0x08, 0x21, 0x22, 0x0a, 
+	0x1b, 0x17, 0x0a, 0x0f, 0x1b, 0x0c, 0x01, 0x01, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 
+	0x01, 0x01, 0x08, 0x0c, 0x0f, 0x16, 0x23, 0x06, 0x08, 
+	0x07, 0x0f, 0x24, 0x25, 0x0a, 0x17, 0x0a, 0x0f, 0x1b, 
+	0x1b, 0x08, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x1e, 
+	0x1b, 0x0c, 0x13, 0x11, 0x07, 0x0f, 0x26, 0x27, 0x24, 
+	0x0e, 0x0e, 0x16, 0x1b, 0x0c, 0x08, 0x01, 0x01, 0x01, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 
+	0x01, 0x01, 0x01, 0x01, 0x05, 0x0c, 0x1b, 0x1b, 0x1b, 
+	0x19, 0x24, 0x28, 0x26, 0x1d, 0x0d, 0x1b, 0x0c, 0x1b, 
+	0x1e, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x29, 0x29, 0x29, 0x2a, 0x2b, 
+	0x2a, 0x1e, 0x1b, 0x0a, 0x2c, 0x2d, 0x2d, 0x28, 0x28, 
+	0x27, 0x2c, 0x21, 0x1b, 0x0c, 0x05, 0x01, 0x01, 0x01, 
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x0c, 0x0a, 
+	0x26, 0x28, 0x28, 0x28, 0x28, 0x28, 0x24, 0x0a, 0x1b, 
+	0x17, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x29, 0x29, 0x29, 
+	0x29, 0x29, 0x29, 0x1b, 0x0a, 0x28, 0x28, 0x28, 0x28, 
+	0x28, 0x28, 0x24, 0x0a, 0x1b, 0x22, 0x01, 0x01, 0x01, 
+	0x01, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 
+	0x16, 0x2e, 0x28, 0x28, 0x28, 0x28, 0x2f, 0x1d, 0x0a, 
+	0x0c, 0x29, 0x30, 0x01, 0x01, 0x29, 0x29, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x29, 0x29, 
+	0x29, 0x29, 0x29, 0x29, 0x29, 0x1b, 0x2e, 0x28, 0x28, 
+	0x28, 0x28, 0x24, 0x0a, 0x0d, 0x1b, 0x29, 0x29, 0x01, 
+	0x29, 0x29, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 
+	0x29, 0x29, 0x1d, 0x2e, 0x28, 0x28, 0x28, 0x24, 0x0a, 
+	0x0c, 0x29, 0x29, 0x29, 0x01, 0x29, 0x29, 0x29, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x29, 
+	0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x0a, 0x24, 
+	0x28, 0x28, 0x28, 0x2e, 0x0a, 0x1b, 0x29, 0x29, 0x29, 
+	0x01, 0x29, 0x29, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 
+	0x29, 0x29, 0x29, 0x0a, 0x24, 0x28, 0x28, 0x2e, 0x24, 
+	0x0a, 0x1b, 0x29, 0x29, 0x29, 0x31, 0x29, 0x29, 0x29, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 
+	0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x16, 
+	0x32, 0x2e, 0x28, 0x2e, 0x24, 0x0a, 0x0c, 0x29, 0x29, 
+	0x29, 0x29, 0x29, 0x29, 0x29, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x29, 0x29, 0x29, 0x29, 0x29, 
+	0x29, 0x29, 0x29, 0x29, 0x1b, 0x0a, 0x2e, 0x2e, 0x24, 
+	0x32, 0x0d, 0x1b, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 
+	0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 
+	0x0c, 0x0d, 0x32, 0x24, 0x32, 0x0d, 0x1b, 0x0c, 0x29, 
+	0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x29, 0x29, 0x29, 
+	0x29, 0x29, 0x29, 0x29, 0x0d, 0x1b, 0x1b, 0x0a, 0x24, 
+	0x0a, 0x1b, 0x0c, 0x25, 0x29, 0x29, 0x29, 0x29, 0x29, 
+	0x29, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x0d, 
+	0x0a, 0x1b, 0x0c, 0x0a, 0x32, 0x0a, 0x1b, 0x1b, 0x0a, 
+	0x0d, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x29, 0x29, 
+	0x29, 0x29, 0x29, 0x0d, 0x0a, 0x0a, 0x25, 0x1b, 0x0d, 
+	0x09, 0x09, 0x0c, 0x25, 0x0a, 0x0a, 0x0d, 0x29, 0x29, 
+	0x29, 0x29, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x29, 0x29, 0x29, 0x29, 0x29, 0x0f, 0x0a, 
+	0x0a, 0x0d, 0x0d, 0x03, 0x33, 0x34, 0x01, 0x03, 0x09, 
+	0x0a, 0x0a, 0x0a, 0x0f, 0x29, 0x29, 0x29, 0x29, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x29, 
+	0x29, 0x29, 0x29, 0x0a, 0x0a, 0x03, 0x03, 0x03, 0x29, 
+	0x29, 0x01, 0x01, 0x34, 0x22, 0x09, 0x03, 0x0c, 0x29, 
+	0x29, 0x29, 0x29, 0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 
+	0x29, 0x35, 0x35, 0x35, 0x0e, 0x01, 0x01, 0x01, 0x01, 
+	0x35, 0x35, 0x35, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 
+	0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x1b, 0x1a, 
+	0x06, 0x01, 0x01, 0x01, 0x01, 0x1a, 0x06, 0x1a, 0x29, 
+	0x29, 0x29, 0x29, 0x29, 0x29, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x29, 0x29, 0x29, 0x29, 0x29, 
+	0x36, 0x08, 0x36, 0x1a, 0x08, 0x08, 0x36, 0x01, 0x01, 
+	0x36, 0x08, 0x08, 0x08, 0x36, 0x08, 0x36, 0x29, 0x29, 
+	0x29, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 
+};
+
+#endif
\ No newline at end of file
diff --git a/backends/wince/findgame.cpp b/backends/wince/findgame.cpp
new file mode 100644
index 0000000000..3157397d54
--- /dev/null
+++ b/backends/wince/findgame.cpp
@@ -0,0 +1,556 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#ifdef _WIN32_WCE
+
+// Browse directories to locate SCUMM games
+
+#include "stdafx.h"
+#include <assert.h>
+#include <Winuser.h>
+#include <Winnls.h>
+#include "resource.h"
+#include "scumm.h"
+#include "config-file.h"
+
+extern Config *scummcfg;
+
+#define MAX_GAMES 20
+
+struct ScummGame {
+	const char *gamename;
+	const char *description;
+	const char *directory;
+	const char *check_file_1;
+	const char *check_file_2;
+	const char *filename;
+	unsigned char next_demo;
+};
+
+struct InstalledScummGame {
+	unsigned char reference;
+	TCHAR directory[MAX_PATH];
+};
+
+static const ScummGame GameList[] = {
+	{	
+		 "Simon The Sorcerer 1 (dos)",
+		 "Completable",
+		 "", "1631.VGA", "GAMEPC",
+		 "simon1dos",
+		 0
+	},
+	{	 
+		 "Simon The Sorcerer 1 (win)",
+		 "Completable",
+		 "", "SIMON.GME", "GAMEPC",
+		 "simon1win",
+		 0
+	},
+	{	 
+		 "Simon The Sorcerer 2 (win)",
+		 "To be tested",
+		 "", "SIMON2.GME", "GSPTR30",
+		 "simon2win",
+		 0
+	},
+	{ 
+		 "Indiana Jones 3 (new)", 
+	     "Buggy, playable a bit", 
+		 "indy3", "", "", 
+		 "indy3",
+	     0 
+	},
+	{	 
+		 "Zak Mc Kracken (new)",
+		 "Completable",
+		 "zak256", "", "",
+		 "zak256",
+		 0
+	},
+	{
+		 "Loom (old)",
+		 "Not working",
+		 "loom", "", "",
+		 "loom",
+		 0
+	},
+	{
+		 "Monkey Island 1 (EGA)",
+		 "Not tested",
+		 "monkeyEGA", "", "",
+		 "monkeyEGA",
+		 0
+	},
+	{
+		 "Loom (VGA)",
+		 "Completable, MP3 audio",
+		 "loomcd", "", "",
+		 "loomcd",
+		 0
+	},
+	{
+		 "Monkey Island 1 (VGA)",
+		 "Completable, MP3 music",
+		 "", "MONKEY.000", "MONKEY.001",
+		 "monkey",
+		 0
+	},
+	{
+		 "Monkey Island 2 (VGA)",
+		 "Completable",
+		 "", "MONKEY2.000", "MONKEY2.001",
+		 "monkey2",
+		 0
+	},
+	{
+		 "Indiana Jones 4",
+		 "Completable",
+		 "", "ATLANTIS.000", "ATLANTIS.001",
+		 "atlantis",
+		 1
+	},
+	{
+		 "Indiana Jones 4 demo",
+		 "Completable",
+		 "", "PLAYFATE.000", "PLAYFATE.001",
+		 "playfate",
+		 0
+	},
+	{
+		 "Day of the Tentacle",
+		 "Completable",
+		 "", "TENTACLE.000", "TENTACLE.001",
+		 "tentacle",
+		 1
+	},
+	{
+		 "Day of the Tentacle demo",
+		 "Completable",
+		 "", "DOTTDEMO.000", "DOTTDEMO.001",
+		 "dottdemo",
+		 0
+	},
+	{	
+		 "Sam & Max",
+		 "Completable, music glitches",
+		 "", "SAMNMAX.000", "SAMNMAX.001",
+		 "samnmax",
+		 1
+	},
+	{
+		 "Sam & Max demo",
+		 "Completable",
+		 "", "SNMDEMO.000", "SNMDEMO.001",
+		 "snmdemo",
+		 0
+	},
+	{
+		 "Full Throttle",
+		 "Partially working",
+		 "", "FT.LA0", "FT.LA1",
+		 "ft",
+		 0
+	},
+	{
+		 "The Dig",
+		 "Partially working",
+		 "", "DIG.LA0", "DIG.LA1",
+		 "dig",
+		 0
+	},
+	{
+		 NULL, NULL, NULL, NULL, NULL, NULL, 0
+	}
+};
+
+void findGame(TCHAR*);
+int displayFoundGames(void);
+void doScan();
+void startFindGame();
+
+char gamesFound[MAX_GAMES];
+unsigned char listIndex[MAX_GAMES];
+InstalledScummGame gamesInstalled[MAX_GAMES];
+int installedGamesNumber;
+HWND hwndDlg;
+TCHAR basePath[MAX_PATH];
+TCHAR old_basePath[MAX_PATH];
+BOOL prescanning;
+
+BOOL isPrescanning() {
+	return prescanning;
+}
+
+void setFindGameDlgHandle(HWND x) {
+	hwndDlg = x;
+}
+
+bool loadGameSettings() {
+	int				index;
+	int				i;
+	const char		*current;
+
+	prescanning = FALSE;
+
+	current = scummcfg->get("GamesInstalled", "wince");
+	if (!current)
+		return FALSE;
+	index = atoi(current);
+
+	installedGamesNumber = index;
+
+	current = scummcfg->get("GamesReferences", "wince");
+	if (!current)
+		return FALSE;
+	for (i=0; i<index; i++) {
+		char x[6];
+		int j;
+
+		memset(x, 0, sizeof(x));
+		memcpy(x, current + 3 * i, 2);
+		sscanf(x, "%x", &j);
+		gamesFound[j] = 1;
+		gamesInstalled[i].reference = j;
+	}
+
+	current = scummcfg->get("BasePath", "wince");
+	if (!current)
+		return FALSE;
+	MultiByteToWideChar(CP_ACP, 0, current, strlen(current) + 1, basePath, sizeof(basePath));
+
+	for (i=0; i<index; i++) {
+		char keyName[100];
+
+		sprintf(keyName, "GamesDirectory%d", i);
+		current = scummcfg->get(keyName, "wince");
+		if (!current)
+			return FALSE;
+		MultiByteToWideChar(CP_ACP, 0, current, strlen(current) + 1, gamesInstalled[i].directory, sizeof(gamesInstalled[i].directory));
+	}
+
+	displayFoundGames();
+
+	return TRUE;
+}
+
+int countGameReferenced(int reference, int *infos) {
+	int i;
+	int number = 0;
+
+	for (i=0; i<installedGamesNumber; i++)
+		if (gamesInstalled[i].reference == reference) 
+			infos[number++] = i;
+
+	return number;
+}
+
+int displayFoundGames() {
+
+	int i;
+	int index = 0;
+
+	for (i = 0; i< MAX_GAMES; i++) {
+		ScummGame current_game;
+		char    work[400];
+		TCHAR	desc[400];
+		int		numberReferenced;
+		int		infos[10];
+		int		j;
+
+		current_game = GameList[i];
+		if (!current_game.filename)
+			break;
+		if (!gamesFound[i])
+			continue;
+		
+		numberReferenced = countGameReferenced(i, infos);
+
+		for (j=0; j<numberReferenced; j++) {
+			if (numberReferenced != 1)
+				sprintf(work, "%s (%d)", current_game.gamename, j + 1);
+			else
+				strcpy(work, current_game.gamename);
+			MultiByteToWideChar(CP_ACP, 0, work, strlen(work) + 1, desc, sizeof(desc));
+			SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), LB_ADDSTRING, 0, (LPARAM)desc);
+			listIndex[index++] = infos[j];
+		}
+	}
+
+	return index;
+
+}
+
+void changeScanPath() {
+	int item;
+	TCHAR path[MAX_PATH];
+
+	item = SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), LB_GETCURSEL, 0, 0);
+	if (item == LB_ERR)
+		return;
+
+	SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), LB_GETTEXT, item, (LPARAM)path);
+
+	if (wcscmp(path, TEXT("..")) != 0) {
+		wcscat(basePath, TEXT("\\"));
+		wcscat(basePath, path);
+	}
+	else {
+		TCHAR *work;
+		
+		work = wcsrchr(basePath, '\\');
+		*work = 0;
+		*(work + 1) = 0;
+	}
+
+	doScan();
+}
+
+void doScan() {
+	WIN32_FIND_DATA	 desc;
+	TCHAR			 searchPath[MAX_PATH];
+	HANDLE			 x;
+
+	SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), LB_RESETCONTENT, 0, 0);
+
+	if (wcslen(basePath) != 0)
+		SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), LB_ADDSTRING, 0, (LPARAM)TEXT(".."));
+
+	wsprintf(searchPath, TEXT("%s\\*"), basePath);
+
+	x = FindFirstFile(searchPath, &desc);
+	if (x == INVALID_HANDLE_VALUE)
+		return;
+	if (desc.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+		TCHAR *work;
+
+		work = wcsrchr(desc.cFileName, '\\');
+		SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), 
+			LB_ADDSTRING, 0, (LPARAM)(work ? work + 1 : desc.cFileName));
+	}
+	while (FindNextFile(x, &desc))
+		if (desc.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+		TCHAR *work;
+
+		work = wcsrchr(desc.cFileName, '\\');
+		SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), 
+			LB_ADDSTRING, 0, (LPARAM)(work ? work + 1 : desc.cFileName));
+	}	
+	FindClose(x);
+}
+
+void startScan() {
+	prescanning = TRUE;
+	wcscpy(old_basePath, basePath);
+	SetDlgItemText(hwndDlg, IDC_FILEPATH, TEXT("Choose the games root directory"));
+	SetDlgItemText(hwndDlg, IDC_SCAN, TEXT("OK"));
+	SetDlgItemText(hwndDlg, IDC_GAMEDESC, TEXT(""));
+	ShowWindow(GetDlgItem(hwndDlg, IDC_PLAY), SW_HIDE);
+	doScan();
+}
+
+void endScanPath() {
+	prescanning = FALSE;
+	SetDlgItemText(hwndDlg, IDC_SCAN, TEXT("Scan"));
+	ShowWindow(GetDlgItem(hwndDlg, IDC_PLAY), SW_SHOW);
+	startFindGame();
+}
+
+void abortScanPath() {
+	prescanning = FALSE;
+	wcscpy(basePath, old_basePath);
+	SetDlgItemText(hwndDlg, IDC_FILEPATH, TEXT(""));
+	SetDlgItemText(hwndDlg, IDC_SCAN, TEXT("Scan"));	
+	SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), LB_RESETCONTENT, 0, 0);
+	ShowWindow(GetDlgItem(hwndDlg, IDC_PLAY), SW_SHOW);
+	displayFoundGames();
+}
+
+void startFindGame() {
+	//TCHAR			fileName[MAX_PATH];
+	//TCHAR			*tempo;
+	int				i = 0;
+	int		    	index = 0;
+	char			tempo[1024];
+	char		    workdir[MAX_PATH];	
+
+	prescanning = FALSE;
+
+	SetDlgItemText(hwndDlg, IDC_FILEPATH, TEXT("Scanning, please wait"));
+
+	SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), LB_RESETCONTENT, 0, 0);
+
+	memset(gamesFound, 0, MAX_GAMES);
+	/*
+	GetModuleFileName(NULL, fileName, MAX_PATH);
+	tempo = wcsrchr(fileName, '\\');
+	*tempo = '\0';
+	*(tempo + 1) = '\0';
+	*/
+	installedGamesNumber = 0;
+
+	//findGame(fileName);
+	findGame(basePath);
+
+	// Display the results
+	index = displayFoundGames();
+
+	// Save the results in the registry
+	SetDlgItemText(hwndDlg, IDC_FILEPATH, TEXT("Saving the results"));
+
+	scummcfg->set("GamesInstalled", index, "wince");
+
+	tempo[0] = '\0';
+	for (i=0; i<index; i++) {
+		char x[3];
+		sprintf(x, "%.2x ", gamesInstalled[i].reference);
+		strcat(tempo, x);
+	}	
+
+	scummcfg->set("GamesReferences", tempo, "wince");
+
+	WideCharToMultiByte(CP_ACP, 0, basePath, wcslen(basePath) + 1, workdir, sizeof(workdir), NULL, NULL);
+
+	scummcfg->set("BasePath", workdir, "wince");
+
+	for (i=0; i<index; i++) {
+		char keyName[100];
+
+		sprintf(keyName, "GamesDirectory%d", i);
+		WideCharToMultiByte(CP_ACP, 0, gamesInstalled[i].directory, wcslen(gamesInstalled[i].directory) + 1, workdir, sizeof(workdir), NULL, NULL);
+		scummcfg->set(keyName, workdir, "wince");
+	}
+
+	scummcfg->flush();
+
+	SetDlgItemText(hwndDlg, IDC_FILEPATH, TEXT("Scan finished"));
+
+}
+
+void getSelectedGame(int result, char *id, TCHAR *directory) {
+	ScummGame game;
+
+	game = GameList[gamesInstalled[listIndex[result]].reference];
+	strcpy(id, game.filename);
+	wcscpy(directory, gamesInstalled[listIndex[result]].directory);
+}
+
+void displayGameInfo() {
+	int item;	
+	TCHAR work[400];
+	ScummGame game;
+
+	item = SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), LB_GETCURSEL, 0, 0);
+	if (item == LB_ERR)
+		return;
+
+	game = GameList[gamesInstalled[listIndex[item]].reference];
+	wcscpy(work, TEXT("File path : ..."));	
+	wcscat(work, wcsrchr(gamesInstalled[listIndex[item]].directory, '\\'));			
+	SetDlgItemText(hwndDlg, IDC_FILEPATH, work);
+	MultiByteToWideChar(CP_ACP, 0, game.description, strlen(game.description) + 1, work, sizeof(work));
+	SetDlgItemText(hwndDlg, IDC_GAMEDESC, work);	
+}
+
+void findGame(TCHAR *directory) {
+	TCHAR			 fileName[MAX_PATH];
+	TCHAR			 newDirectory[MAX_PATH];
+	WIN32_FIND_DATA	 desc;
+	HANDLE			 x;
+	int				 i;
+
+	// Check for games in the current directory
+
+	//MessageBox(NULL, directory, TEXT("Current"), MB_OK);
+
+	for (i = 0 ; i < MAX_GAMES ; i++) {
+		ScummGame current_game;
+
+		current_game = GameList[i];
+		if (!current_game.filename)
+			break;
+
+		if (strlen(current_game.directory)) {
+			// see if the last directory matches
+			TCHAR	*work;
+			char	curdir[MAX_PATH];
+
+			
+			work = wcsrchr(directory, '\\');
+			WideCharToMultiByte(CP_ACP, 0, work + 1, wcslen(work + 1) + 1, curdir, sizeof(curdir), NULL, NULL);
+			if (stricmp(curdir, current_game.directory) == 0) {
+				
+				//MessageBox(NULL, TEXT("Match directory !"), TEXT("..."), MB_OK);
+				
+				gamesFound[i] = 1;
+				gamesInstalled[installedGamesNumber].reference = i;
+				wcscpy(gamesInstalled[installedGamesNumber].directory, directory);
+				installedGamesNumber++;
+			}
+		}
+		else
+		{
+			TCHAR	work[MAX_PATH];
+			TCHAR	checkfile[MAX_PATH];
+
+
+			MultiByteToWideChar(CP_ACP, 0, current_game.check_file_1, strlen(current_game.check_file_1) + 1, checkfile, sizeof(checkfile));
+			wsprintf(work, TEXT("%s\\%s"), directory, checkfile);
+			//MessageBox(NULL, work, TEXT("Checking file"), MB_OK);
+
+			if (GetFileAttributes(work) == 0xFFFFFFFF)
+				continue;
+
+			//MessageBox(NULL, TEXT("Check OK"), TEXT("Checking file"), MB_OK);
+			MultiByteToWideChar(CP_ACP, 0, current_game.check_file_2, strlen(current_game.check_file_2) + 1, checkfile, sizeof(checkfile));
+			wsprintf(work, TEXT("%s\\%s"), directory, checkfile);			
+			if (GetFileAttributes(work) == 0xFFFFFFFF)
+				continue;
+			
+			//MessageBox(NULL, TEXT("Match file !"), TEXT("..."), MB_OK);
+			gamesFound[i] = 1;
+			gamesInstalled[installedGamesNumber].reference = i;
+			wcscpy(gamesInstalled[installedGamesNumber].directory, directory);
+			installedGamesNumber++;
+
+		}
+	}
+
+	// Recurse
+
+	wsprintf(fileName, TEXT("%s\\*"), directory);
+
+	x = FindFirstFile(fileName, &desc);
+	if (x == INVALID_HANDLE_VALUE)
+		return;
+	if (desc.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+		wsprintf(newDirectory, TEXT("%s\\%s"), directory, desc.cFileName);
+		findGame(newDirectory);
+	}
+	while (FindNextFile(x, &desc))
+		if (desc.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+		wsprintf(newDirectory, TEXT("%s\\%s"), directory, desc.cFileName);
+		findGame(newDirectory);
+	}	
+	FindClose(x);
+}
+
+#endif
\ No newline at end of file
diff --git a/backends/wince/gapi_keys.cpp b/backends/wince/gapi_keys.cpp
new file mode 100644
index 0000000000..a4d2677573
--- /dev/null
+++ b/backends/wince/gapi_keys.cpp
@@ -0,0 +1,341 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#ifdef _WIN32_WCE
+
+// Handle mapping of actions to hardware keys
+
+#include "stdafx.h"
+#include <assert.h>
+#include <Winuser.h>
+#include <sipapi.h>
+#include <Aygshell.h>
+#include <gx.h>
+
+#include "gapi_keys.h"
+
+#include "screen.h"
+
+struct oneAction _actions[NUMBER_ACTIONS];
+struct GXKeyList _portrait_keys;
+struct GXKeyList _landscape_keys;
+pAction *_action_functions;
+
+const char* ActionsText[] = {
+	"None",
+	"Pause",
+	"Save",
+	"Quit",
+	"Skip",
+	"Hide",
+	"Keyboard",
+	"Sound",
+	"Right click",
+	"Cursor on/off",
+	"Subtitles on/off",
+	"Boss"
+};
+
+bool _typeExists(int x) {
+	int i;
+
+	for (i=0; i<NUMBER_ACTIONS; i++)
+		if (_actions[i].action_type == x)
+			return true;
+
+	return false;
+}
+
+
+const char* getActionName(int action) {
+	return ActionsText[action];
+}
+
+void GAPIKeysInit(pAction *functions) {
+	int i;
+	GXOpenInput();
+	for (i=0; i<NUMBER_ACTIONS; i++) {
+		_actions[i].action_key = 0;
+	}
+
+	/* Default actions */
+
+	_actions[0].action_type = ACTION_PAUSE;
+	_actions[1].action_type = ACTION_SAVE;
+	_actions[2].action_type = ACTION_QUIT;
+	_actions[3].action_type = ACTION_SKIP;
+	_actions[4].action_type = ACTION_HIDE;
+
+	_action_functions = functions;
+	GAPIKeysGetReference();
+}
+
+void GAPIKeysGetReference() {
+	/*
+	if(GetScreenMode()) {
+		_keys = GXGetDefaultKeys(GX_LANDSCAPEKEYS);
+	} else {
+		_keys = GXGetDefaultKeys(GX_NORMALKEYS);
+	}
+	*/
+
+	_portrait_keys = GXGetDefaultKeys(GX_NORMALKEYS);
+	_landscape_keys = GXGetDefaultKeys(GX_LANDSCAPEKEYS);
+}
+
+int GAPIKeysTranslate(int key) {
+/*
+	if (key == _landscape_keys.vkUp)
+		return _portrait_keys.vkUp;
+	if (key == _landscape_keys.vkDown)
+		return _portrait_keys.vkDown;
+	if (key == _landscape_keys.vkLeft)
+		return _portrait_keys.vkLeft;
+	if (key == _landscape_keys.vkRight)
+		return _portrait_keys.vkRight;
+	if (key == _landscape_keys.vkA)
+		return _portrait_keys.vkA;
+	if (key == _landscape_keys.vkB)
+		return _portrait_keys.vkB;
+	if (key == _landscape_keys.vkC)
+		return _portrait_keys.vkC;
+	if (key == _landscape_keys.vkStart)
+		return _portrait_keys.vkStart;
+*/
+	return key;
+}
+
+/*
+const unsigned char getGAPIKeyMapping(short key) {
+	// first the standard GAPI controls
+	if (key == _keys.vkA)
+		return GAPI_KEY_VKA;
+	
+	if (key == _keys.vkB)
+			return GAPI_KEY_VKB;
+	
+	if (key == _keys.vkC)
+			return GAPI_KEY_VKC;
+	
+	if (key == _keys.vkStart)
+			return GAPI_KEY_VKSTART;
+
+	if (key == _keys.vkUp) 
+			return GAPI_KEY_VKUP;
+
+	if (key == _keys.vkDown)
+			return GAPI_KEY_VKDOWN;
+
+	if (key == _keys.vkLeft)
+			return GAPI_KEY_VKLEFT;
+
+	if (key == _keys.vkRight)
+			return GAPI_KEY_VKRIGHT;
+
+	switch (key) {
+		// then the "unsupported" keys 
+		case INTERNAL_KEY_CALENDAR:
+			return GAPI_KEY_CALENDAR;
+		case INTERNAL_KEY_CONTACTS:
+			return GAPI_KEY_CONTACTS;
+		case INTERNAL_KEY_INBOX:
+			return GAPI_KEY_INBOX;
+		case INTERNAL_KEY_ITASK:
+			return GAPI_KEY_ITASK;
+		default:
+			return 0;
+	}
+}
+*/
+
+const char* getGAPIKeyName(int key) {
+	static char key_name[50];
+
+	if (!key)
+		return "Not mapped";
+	if (key == _portrait_keys.vkA)
+		return "Button A";
+	if (key == _portrait_keys.vkB)
+		return "Button B";
+	if (key == _portrait_keys.vkC)
+		return "Button C";
+	if (key == _portrait_keys.vkStart)
+		return "Button Start";
+	if (key == _portrait_keys.vkUp)
+		return "Pad Up";
+	if (key == _portrait_keys.vkDown)
+		return "Pad Down";
+	if (key == _portrait_keys.vkLeft)
+		return "Pad Left";
+	if (key == _portrait_keys.vkRight)
+		return "Pad Right";
+	if (key == INTERNAL_KEY_CALENDAR)
+		return "Button Calendar";
+	if (key == INTERNAL_KEY_CONTACTS)
+		return "Button Contacts";
+	if (key == INTERNAL_KEY_INBOX)
+		return "Button Inbox";
+	if (key == INTERNAL_KEY_ITASK)
+		return "Button ITask";
+	sprintf(key_name, "Key %.4x", key);
+		return key_name;
+
+/*
+	switch(key) {
+		case 0:
+			return "Not mapped";
+		case GAPI_KEY_VKA:
+			return "Button A";
+		case GAPI_KEY_VKB:
+			return "Button B";
+		case GAPI_KEY_VKC:
+			return "Button C";
+		case GAPI_KEY_VKSTART:
+			return "Button Start";
+		case GAPI_KEY_CALENDAR:
+			return "Button Calendar";
+		case GAPI_KEY_CONTACTS:
+			return "Button Contacts";
+		case GAPI_KEY_INBOX:
+			return "Button Inbox";
+		case GAPI_KEY_ITASK:
+			return "Button ITask";
+		case GAPI_KEY_VKUP:
+			return "Pad Up";
+		case GAPI_KEY_VKDOWN:
+			return "Pad Down";
+		case GAPI_KEY_VKLEFT:
+			return "Pad Left";
+		case GAPI_KEY_VKRIGHT:
+			return "Pad Right";
+		default:
+			sprintf(key_name, "Unknown key %.4x", key);
+			return key_name;
+	}
+*/
+}
+
+struct oneAction* getAction(int action) {
+	return &_actions[action];
+}
+
+bool processAction (int key) {
+	int i;
+	/*
+	unsigned char GAPI_key;
+
+	GAPI_key = getGAPIKeyMapping(key);
+	if (!GAPI_key)
+		return;
+	*/
+
+	for (i=0; i<NUMBER_ACTIONS; i++) 
+		//if (_actions[i].action_key == GAPI_key &&
+		if (_actions[i].action_key == key &&
+			_actions[i].action_type != ACTION_NONE &&
+			_action_functions[_actions[i].action_type - 1]) {
+					_action_functions[_actions[i].action_type - 1]();
+					return true;
+		}
+
+	return false;
+}
+
+void clearActionKey (unsigned char key) {
+	int i;
+
+	for (i=0; i<NUMBER_ACTIONS; i++)
+		if (_actions[i].action_key == key) {
+			_actions[i].action_key = 0;
+		}
+}
+
+const int* getActionKeys() {
+	int i;
+	static int actionKeys[NUMBER_ACTIONS];
+
+	for (i=0; i<NUMBER_ACTIONS; i++)
+		actionKeys[i] = _actions[i].action_key;
+
+	return actionKeys;
+}
+
+const unsigned char* getActionTypes() {
+	int i;
+	static unsigned char actionTypes[NUMBER_ACTIONS];
+
+	for (i=0; i<NUMBER_ACTIONS; i++)
+		actionTypes[i] = _actions[i].action_type;
+
+	return actionTypes;
+
+}
+
+void setNextType(int action) {
+	int start = _actions[action].action_type;
+	int current = start;
+	for (;;) {
+		current++;
+		if (current == start)
+			return;
+		if (current > TOTAL_ACTIONS)
+			current = 1;
+		if (!_typeExists(current)) {
+				_actions[action].action_type = current;
+				return;
+		}
+	}
+}
+
+void setPreviousType(int action) {
+	int start = _actions[action].action_type;
+	int current = start;
+	for (;;) {
+		current--;
+		if (current == start)
+			return;
+		if (current <= 0)
+			current = TOTAL_ACTIONS;
+		if (!_typeExists(current)) {
+				_actions[action].action_type = current;
+				return;
+		}
+	}
+}
+
+
+
+void setActionKeys(int *actionKeys) {
+	int i;
+
+	for (i=0; i<NUMBER_ACTIONS; i++)
+		_actions[i].action_key = actionKeys[i];
+}
+
+void setActionTypes(unsigned char *actionTypes) {
+	int i;
+
+	for (i=0; i<NUMBER_ACTIONS; i++)
+		_actions[i].action_type = (ActionType)actionTypes[i];
+}
+
+
+#endif
\ No newline at end of file
diff --git a/backends/wince/gapi_keys.h b/backends/wince/gapi_keys.h
new file mode 100644
index 0000000000..5eee52e518
--- /dev/null
+++ b/backends/wince/gapi_keys.h
@@ -0,0 +1,62 @@
+#ifdef _WIN32_WCE
+
+typedef void (*pAction)();
+
+enum ActionType {
+	ACTION_NONE = 0,
+	ACTION_PAUSE = 1,
+	ACTION_SAVE = 2,
+	ACTION_QUIT = 3,
+	ACTION_SKIP = 4,
+	ACTION_HIDE = 5,
+	ACTION_KEYBOARD = 6,
+	ACTION_SOUND = 7,
+	ACTION_RIGHTCLICK = 8,
+	ACTION_CURSOR = 9,
+	ACTION_SUBTITLES = 10
+};
+
+struct oneAction {
+	unsigned char	action_key;
+	int				action_type;
+};
+
+
+#define NUMBER_ACTIONS 10
+#define TOTAL_ACTIONS 10
+
+#define GAPI_KEY_BASE 1000
+#define GAPI_KEY_VKA 1
+#define GAPI_KEY_VKB 2
+#define GAPI_KEY_VKC 3
+#define GAPI_KEY_VKSTART 4
+#define GAPI_KEY_CALENDAR 5
+#define GAPI_KEY_CONTACTS 6
+#define GAPI_KEY_INBOX 7
+#define GAPI_KEY_ITASK 8
+#define GAPI_KEY_VKUP 9
+#define GAPI_KEY_VKDOWN 10
+#define GAPI_KEY_VKLEFT 11
+#define GAPI_KEY_VKRIGHT 12
+
+#define INTERNAL_KEY_CALENDAR 0xc1
+#define INTERNAL_KEY_CONTACTS 0xc2
+#define INTERNAL_KEY_INBOX 0xc3
+#define INTERNAL_KEY_ITASK 0xc4
+
+void GAPIKeysInit(pAction*);
+void GAPIKeysGetReference(void);
+const unsigned char getGAPIKeyMapping(short);
+const char* getGAPIKeyName(unsigned char);
+struct oneAction* getAction(int);
+void processAction (short);
+void clearActionKey (unsigned char);
+const unsigned char* getActionKeys(void);
+void setActionKeys(unsigned char *);
+const char* getActionName(int);
+void setActionTypes(unsigned char *);
+const unsigned char* getActionTypes();
+void setNextType(int);
+void setPreviousType(int);
+
+#endif
diff --git a/backends/wince/missing/assert.h b/backends/wince/missing/assert.h
new file mode 100644
index 0000000000..ada1a466e6
--- /dev/null
+++ b/backends/wince/missing/assert.h
@@ -0,0 +1,3 @@
+/* Header is not present in Windows CE SDK */
+
+#define assert(a) ;
\ No newline at end of file
diff --git a/backends/wince/missing/conio.h b/backends/wince/missing/conio.h
new file mode 100644
index 0000000000..0cb5c297ea
--- /dev/null
+++ b/backends/wince/missing/conio.h
@@ -0,0 +1,2 @@
+/* Header is not present in Windows CE SDK */
+
diff --git a/backends/wince/missing/dir.h b/backends/wince/missing/dir.h
new file mode 100644
index 0000000000..b9497bc7f9
--- /dev/null
+++ b/backends/wince/missing/dir.h
@@ -0,0 +1 @@
+/* Header is not present in Windows CE SDK */
\ No newline at end of file
diff --git a/backends/wince/missing/direct.h b/backends/wince/missing/direct.h
new file mode 100644
index 0000000000..7ee9f5e5ba
--- /dev/null
+++ b/backends/wince/missing/direct.h
@@ -0,0 +1 @@
+/* Header is not present in Windows CE SDK */
diff --git a/backends/wince/missing/dirent.h b/backends/wince/missing/dirent.h
new file mode 100644
index 0000000000..82dd0b2ee7
--- /dev/null
+++ b/backends/wince/missing/dirent.h
@@ -0,0 +1,52 @@
+/* Header is not present in Windows CE SDK */
+/* It would not be a bad idea to take this thing from gcc distro and port
+   it properly. For now only required part is ported. */
+
+struct dirent
+{
+	long		d_ino;		/* Always zero. */
+	unsigned short	d_reclen;	/* Always zero. */
+	unsigned short	d_namlen;	/* Length of name in d_name. */
+	char*		d_name; 	/* File name. */
+	/* NOTE: The name in the dirent structure points to the name in the
+	 *		 finddata_t structure in the DIR. */
+};
+
+/*
+ * This is an internal data structure. Good programmers will not use it
+ * except as an argument to one of the functions below.
+ */
+typedef struct
+{
+	/* disk transfer area for this dir */
+/*	struct _finddata_t	dd_dta; */
+
+	/* dirent struct to return from dir (NOTE: this makes this thread
+	 * safe as long as only one thread uses a particular DIR struct at
+	 * a time) */
+	struct dirent		dd_dir;
+
+	/* _findnext handle */
+	long			dd_handle;
+
+	/*
+		 * Status of search:
+	 *	 0 = not started yet (next entry to read is first entry)
+	 *	-1 = off the end
+	 *	 positive = 0 based index of next entry
+	 */
+	short			dd_stat;
+
+	/* given path for dir with search pattern (struct is extended) */
+	char			dd_name[1];
+} DIR;
+
+
+DIR*		opendir (const char*);
+struct dirent*	readdir (DIR*);
+int 	closedir (DIR*);
+/*
+void		rewinddir (DIR*);
+long		telldir (DIR*);
+void		seekdir (DIR*, long);
+*/
diff --git a/backends/wince/missing/errno.h b/backends/wince/missing/errno.h
new file mode 100644
index 0000000000..7ee9f5e5ba
--- /dev/null
+++ b/backends/wince/missing/errno.h
@@ -0,0 +1 @@
+/* Header is not present in Windows CE SDK */
diff --git a/backends/wince/missing/fcntl.h b/backends/wince/missing/fcntl.h
new file mode 100644
index 0000000000..7ee9f5e5ba
--- /dev/null
+++ b/backends/wince/missing/fcntl.h
@@ -0,0 +1 @@
+/* Header is not present in Windows CE SDK */
diff --git a/backends/wince/missing/io.h b/backends/wince/missing/io.h
new file mode 100644
index 0000000000..a7b74c71b7
--- /dev/null
+++ b/backends/wince/missing/io.h
@@ -0,0 +1,15 @@
+/* Header is not present in Windows CE SDK */
+
+/* This stuff will live here until port configuration file is in place */
+#define stricmp _stricmp
+#define strdup _strdup
+#define _HEAPOK 0
+#define _heapchk() 0
+
+#ifndef _FILE_DEFINED
+   typedef void FILE;
+   #define _FILE_DEFINED
+#endif
+FILE* wce_fopen(const char* fname, const char* fmode);
+#define fopen wce_fopen
+
diff --git a/backends/wince/missing/missing.cpp b/backends/wince/missing/missing.cpp
new file mode 100644
index 0000000000..237014dfb2
--- /dev/null
+++ b/backends/wince/missing/missing.cpp
@@ -0,0 +1,378 @@
+/* MISSING.C
+   Implementation for standard and semi-standard C library calls missing in WinCE
+   environment.
+   by Vasyl Tsvirkunov
+*/
+
+#include <windows.h>
+#include <tchar.h>
+#include <string.h>
+#include "sys/stat.h"
+#include "sys/time.h"
+#include "time.h"
+#include "dirent.h"
+
+/* forward declaration */
+char *strdup(const char *strSource);
+
+/* Limited dirent implementation. Used by UI.C and DEVICES.C */
+static WIN32_FIND_DATA wfd;
+
+DIR* opendir(const char* fname)
+{
+	DIR* pdir;
+	char fnameMask[MAX_PATH+1];
+	TCHAR fnameUnc[MAX_PATH+1];
+	char nameFound[MAX_PATH+1];
+	
+	if(fname == NULL)
+		return NULL;
+	
+	strcpy(fnameMask, fname);
+	if(!strlen(fnameMask) || fnameMask[strlen(fnameMask)-1] != '\\')
+		strncat(fnameMask, "\\", MAX_PATH-strlen(fnameMask)-1);
+	strncat(fnameMask, "*.*", MAX_PATH-strlen(fnameMask)-4);
+	
+	pdir = (DIR*)malloc(sizeof(DIR)+strlen(fname));
+	pdir->dd_dir.d_ino = 0;
+	pdir->dd_dir.d_reclen = 0;
+	pdir->dd_dir.d_name = 0;
+	pdir->dd_dir.d_namlen = 0;
+	
+	pdir->dd_handle = 0;
+	pdir->dd_stat = 0;
+	strcpy(pdir->dd_name, fname); /* it has exactly enough space for fname and nul char */
+	
+	MultiByteToWideChar(CP_ACP, 0, fnameMask, -1, fnameUnc, MAX_PATH);
+	if((pdir->dd_handle = (long)FindFirstFile(fnameUnc, &wfd)) == (long)INVALID_HANDLE_VALUE)
+	{
+		free(pdir);
+		return NULL;
+	}
+	else
+	{
+		WideCharToMultiByte(CP_ACP, 0, wfd.cFileName, -1, nameFound, MAX_PATH, NULL, NULL);
+		
+		pdir->dd_dir.d_name = strdup(nameFound);
+		pdir->dd_dir.d_namlen = strlen(nameFound);
+	}
+	return pdir;
+}
+
+struct dirent*	readdir(DIR* dir)
+{
+	char nameFound[MAX_PATH+1];
+	static struct dirent dummy;
+	
+	if(dir->dd_stat == 0)
+	{
+		dummy.d_name = ".";
+		dummy.d_namlen = 1;
+		dir->dd_stat ++;
+		return &dummy;
+	}
+	else if(dir->dd_stat == 1)
+	{
+		dummy.d_name = "..";
+		dummy.d_namlen = 2;
+		dir->dd_stat ++;
+		return &dummy;
+	}
+	else if(dir->dd_stat == 2)
+	{
+		dir->dd_stat++;
+		return &dir->dd_dir;
+	}
+	else
+	{
+		if(FindNextFile((HANDLE)dir->dd_handle, &wfd) == 0)
+		{
+			dir->dd_stat = -1;
+			return NULL;
+		}
+		WideCharToMultiByte(CP_ACP, 0, wfd.cFileName, -1, nameFound, MAX_PATH, NULL, NULL);
+		
+		if(dir->dd_dir.d_name)
+			free(dir->dd_dir.d_name);
+		
+		dir->dd_dir.d_name = strdup(nameFound);
+		dir->dd_dir.d_namlen = strlen(nameFound);
+		
+		dir->dd_stat ++;
+		
+		return &dir->dd_dir;
+	}
+}
+
+int closedir(DIR* dir)
+{
+	if(dir == NULL)
+		return 0;
+	
+	if(dir->dd_handle)
+		FindClose((HANDLE)dir->dd_handle);
+	
+	if(dir->dd_dir.d_name)
+		free(dir->dd_dir.d_name);
+	free(dir);
+	return 1;
+}
+
+/* Very limited implementation of stat. Used by UI.C, MEMORY-P.C (latter is not critical) */
+int stat(const char *fname, struct stat *ss)
+{
+	TCHAR fnameUnc[MAX_PATH+1];
+	HANDLE handle;
+	int len;
+	
+	if(fname == NULL || ss == NULL)
+		return -1;
+	
+	/* Special case (dummy on WinCE) */
+	len = strlen(fname);
+	if(len >= 2 && fname[len-1] == '.' && fname[len-2] == '.' &&
+		(len == 2 || fname[len-3] == '\\'))
+	{
+		/* That's everything implemented so far */
+		memset(ss, 0, sizeof(struct stat));
+		ss->st_size = 1024;
+		ss->st_mode |= S_IFDIR;
+		return 0;
+	}
+	
+	MultiByteToWideChar(CP_ACP, 0, fname, -1, fnameUnc, MAX_PATH);
+	handle = FindFirstFile(fnameUnc, &wfd);
+	if(handle == INVALID_HANDLE_VALUE)
+		return -1;
+	else
+	{
+		/* That's everything implemented so far */
+		memset(ss, 0, sizeof(struct stat));
+		ss->st_size = wfd.nFileSizeLow;
+		if(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+			ss->st_mode |= S_IFDIR;
+		
+		FindClose(handle);
+	}
+	return 0;
+}
+
+/* Remove file by name */
+int remove(const char* path)
+{
+	TCHAR pathUnc[MAX_PATH+1];
+	MultiByteToWideChar(CP_ACP, 0, path, -1, pathUnc, MAX_PATH);
+	return !DeleteFile(pathUnc);
+}
+
+/* in our case unlink is the same as remove */
+int unlink(const char* path)
+{
+	return remove(path);
+}
+
+/* Make directory, Unix style */
+void mkdir(char* dirname, int mode)
+{
+	char  path[MAX_PATH+1];
+	TCHAR pathUnc[MAX_PATH+1];
+	char* ptr;
+	strncpy(path, dirname, MAX_PATH);
+	if(*path == '/')
+		*path = '\\';
+	/* Run through the string and attempt creating all subdirs on the path */
+	for(ptr = path+1; *ptr; ptr ++)
+	{
+		if(*ptr == '\\' || *ptr == '/')
+		{
+			*ptr = 0;
+			MultiByteToWideChar(CP_ACP, 0, path, -1, pathUnc, MAX_PATH);
+			CreateDirectory(pathUnc, 0);
+			*ptr = '\\';
+		}
+	}
+	MultiByteToWideChar(CP_ACP, 0, path, -1, pathUnc, MAX_PATH);
+	CreateDirectory(pathUnc, 0);
+}
+
+/* Used in DEVICES.C and UI.C for some purpose. Not critical in this port */
+int system(const char* path) { return 0; }
+
+
+char *tmpnam(char *string)
+{
+	TCHAR pTemp[MAX_PATH+1];
+	static char buffer[MAX_PATH+1];
+	GetTempFileName(TEXT("."), TEXT("A8_"), 0, pTemp);
+	WideCharToMultiByte(CP_ACP, 0, pTemp, -1, buffer, MAX_PATH, NULL, NULL);
+	
+	if(string)
+	{
+		strcpy(string, buffer);
+		return string;
+	}
+	else
+		return buffer;
+}
+
+FILE *tmpfile()
+{
+	TCHAR pTemp[MAX_PATH+1];
+	if(!GetTempFileName(TEXT("."), TEXT("A8_"), 0, pTemp))
+		return _wfopen(pTemp, TEXT("w+b"));
+	else
+		return 0;
+}
+
+void rewind(FILE *stream)
+{
+	fseek(stream, 0, SEEK_SET);
+}
+
+
+char *strdup(const char *strSource)
+{
+	char* buffer;
+	buffer = (char*)malloc(strlen(strSource)+1);
+	if(buffer)
+		strcpy(buffer, strSource);
+	return buffer;
+}
+
+/* Used in UI.C */
+char cwd[MAX_PATH+1] = "";
+char *getcwd(char *buffer, int maxlen)
+{
+	TCHAR fileUnc[MAX_PATH+1];
+	char* plast;
+	
+	if(cwd[0] == 0)
+	{
+		GetModuleFileName(NULL, fileUnc, MAX_PATH);
+		WideCharToMultiByte(CP_ACP, 0, fileUnc, -1, cwd, MAX_PATH, NULL, NULL);
+		plast = strrchr(cwd, '\\');
+		if(plast)
+			*plast = 0;
+		/* Special trick to keep start menu clean... */
+		if(_stricmp(cwd, "\\windows\\start menu") == 0)
+			strcpy(cwd, "\\Apps");
+	}
+	if(buffer)
+		strncpy(buffer, cwd, maxlen);
+	return cwd;
+}
+
+/* Limited implementation of time.h. time_t formula is possibly incorrect. */
+time_t time(time_t* res)
+{
+	time_t t;
+	SYSTEMTIME st;
+	GetLocalTime(&st);
+	
+	t = (time_t)(((((((st.wYear-1970)*12+st.wMonth)*31+st.wDay)*7+st.wDayOfWeek)*24+st.wHour)*60+st.wMinute)*60+st.wSecond);
+	
+	if(res)
+		*res = t;
+	return t;
+}
+
+struct tm* localtime(time_t* timer)
+{
+	static struct tm tmLocalTime;
+	unsigned long rem = *timer;
+	
+	tmLocalTime.tm_sec  = (short)(rem % 60);
+	rem /= 60;
+	tmLocalTime.tm_min  = (short)(rem % 60);
+	rem /= 60;
+	tmLocalTime.tm_hour = (short)(rem % 24);
+	rem /= 24;
+	tmLocalTime.tm_mday = (short)(rem % 7);
+	rem /= 7;
+	tmLocalTime.tm_mday = (short)(rem % 31);
+	rem /= 31;
+	tmLocalTime.tm_mon  = (short)(rem % 12);
+	rem /= 12;
+	tmLocalTime.tm_year = (short)(rem+1970);
+	
+	return &tmLocalTime;
+}
+
+/* Very limited implementation of sys/time.h */
+void gettimeofday(struct timeval* tp, void* dummy)
+{
+	DWORD dt = GetTickCount();
+	tp->tv_sec = dt/1000;
+	tp->tv_usec = dt*1000;
+}
+
+void usleep(long usec)
+{
+	long msec = usec/1000;
+	if(msec <= 0)
+		Sleep(0);
+	else
+		Sleep(msec);
+}
+
+/*
+Windows CE fopen has non-standard behavior -- not
+fully qualified paths refer to root folder rather
+than current folder (concept not implemented in CE).
+*/
+#undef fopen
+
+FILE* wce_fopen(const char* fname, const char* fmode)
+{
+	char fullname[MAX_PATH+1];
+	
+	if(!fname || fname[0] == '\0')
+		return NULL;
+	if(fname[0] != '\\' && fname[0] != '/')
+	{
+		getcwd(fullname, MAX_PATH);
+		strncat(fullname, "\\", MAX_PATH-strlen(fullname)-1);
+		strncat(fullname, fname, MAX_PATH-strlen(fullname)-strlen(fname));
+		return fopen(fullname, fmode);
+	}
+	else
+		return fopen(fname, fmode);
+}
+
+/* This may provide for better sync mechanism */
+unsigned int clock()
+{
+	return GetTickCount();
+}
+
+/* And why do people use this? */
+void abort()
+{
+	exit(1);
+}
+
+/*
+IMHO, no project should use this one, it is not portable at all. This implementation
+at least allows some projects to work.
+*/
+char* getenv(char* name)
+{
+	static char buffer[MAX_PATH+1];
+	if(strcmp(name, "HOME") == 0 || strcmp(name, "HOMEDIR") == 0)
+	{
+		getcwd(buffer, MAX_PATH);
+		return buffer;
+	}
+	else
+		return "";
+}
+
+void *bsearch(const void *key, const void *base, size_t nmemb, 
+			  size_t size, int (*compar)(const void *, const void *)) {
+	size_t i;
+
+	for (i=0; i<nmemb; i++) 
+		if (compar(key, (void*)((size_t)base + size * i)) == 0)
+			return (void*)((size_t)base + size * i);
+	return NULL;
+}
diff --git a/backends/wince/missing/signal.h b/backends/wince/missing/signal.h
new file mode 100644
index 0000000000..128d6bf1db
--- /dev/null
+++ b/backends/wince/missing/signal.h
@@ -0,0 +1,3 @@
+/* Header is not present in Windows CE SDK */
+/* Functionality is not critical -- Pocket PC devices do not have Ctrl+C */
+#define signal(a,b)
diff --git a/backends/wince/missing/sys/stat.h b/backends/wince/missing/sys/stat.h
new file mode 100644
index 0000000000..d9eef1318d
--- /dev/null
+++ b/backends/wince/missing/sys/stat.h
@@ -0,0 +1,23 @@
+/* Header is not present in Windows CE SDK */
+
+#include <sys/types.h>
+
+struct stat {
+	_dev_t st_dev;
+	_ino_t st_ino;
+	unsigned short st_mode;
+	short st_nlink;
+	short st_uid;
+	short st_gid;
+	_dev_t st_rdev;
+	_off_t st_size;
+	time_t st_atime;
+	time_t st_mtime;
+	time_t st_ctime;
+};
+
+
+#define _S_IFDIR        0040000         /* directory */
+#define S_IFDIR  _S_IFDIR
+
+int stat(const char *, struct stat *);
diff --git a/backends/wince/missing/sys/time.h b/backends/wince/missing/sys/time.h
new file mode 100644
index 0000000000..ded29bb009
--- /dev/null
+++ b/backends/wince/missing/sys/time.h
@@ -0,0 +1,10 @@
+/* Header is not present in Windows CE SDK */
+
+struct timeval
+{
+	int tv_sec;
+	int tv_usec;
+};
+
+void gettimeofday(struct timeval* tp, void* dummy);
+void usleep(long usec);
diff --git a/backends/wince/missing/sys/types.h b/backends/wince/missing/sys/types.h
new file mode 100644
index 0000000000..b6c05e3958
--- /dev/null
+++ b/backends/wince/missing/sys/types.h
@@ -0,0 +1,5 @@
+/* Header is not present in Windows CE SDK */
+
+typedef unsigned short _ino_t;
+typedef unsigned int _dev_t;
+typedef long _off_t;
diff --git a/backends/wince/missing/time.h b/backends/wince/missing/time.h
new file mode 100644
index 0000000000..40c2894dca
--- /dev/null
+++ b/backends/wince/missing/time.h
@@ -0,0 +1,24 @@
+/* Header is not present in Windows CE SDK */
+
+#ifndef A800_TIME_H
+#define A800_TIME_H
+
+#include <stdlib.h>
+
+struct tm
+{
+	short tm_year;
+	short tm_mon;
+	short tm_mday;
+	short tm_wday;
+	short tm_hour;
+	short tm_min;
+	short tm_sec;
+};
+
+time_t time(time_t* dummy);
+struct tm* localtime(time_t* dummy);
+
+unsigned int clock();
+
+#endif
diff --git a/backends/wince/missing/unistd.h b/backends/wince/missing/unistd.h
new file mode 100644
index 0000000000..7ee9f5e5ba
--- /dev/null
+++ b/backends/wince/missing/unistd.h
@@ -0,0 +1 @@
+/* Header is not present in Windows CE SDK */
diff --git a/backends/wince/newres.h b/backends/wince/newres.h
new file mode 100644
index 0000000000..57f429fa45
--- /dev/null
+++ b/backends/wince/newres.h
@@ -0,0 +1,41 @@
+#ifndef __NEWRES_H__
+#define __NEWRES_H__
+
+#if !defined(UNDER_CE)
+#define UNDER_CE _WIN32_WCE
+#endif
+
+#if defined(_WIN32_WCE)
+	#if !defined(WCEOLE_ENABLE_DIALOGEX)
+		#define DIALOGEX DIALOG DISCARDABLE
+	#endif
+	#include <commctrl.h>
+	#define  SHMENUBAR RCDATA
+	#if defined(WIN32_PLATFORM_PSPC) && (_WIN32_WCE >= 300)
+		#include <aygshell.h>
+		#define AFXCE_IDR_SCRATCH_SHMENU  28700
+	#else
+		#define I_IMAGENONE		(-2)
+		#define NOMENU			0xFFFF
+		#define IDS_SHNEW		1
+
+		#define IDM_SHAREDNEW        10
+		#define IDM_SHAREDNEWDEFAULT 11
+	#endif // _WIN32_WCE_PSPC
+	#define AFXCE_IDD_SAVEMODIFIEDDLG 28701
+#endif // _WIN32_WCE
+
+#ifdef RC_INVOKED
+#ifndef _INC_WINDOWS
+#define _INC_WINDOWS
+	#include "winuser.h"           // extract from windows header
+	#include "winver.h"   
+#endif
+#endif
+
+#ifdef IDC_STATIC
+#undef IDC_STATIC
+#endif
+#define IDC_STATIC      (-1)
+
+#endif //__NEWRES_H__
diff --git a/backends/wince/pocketpc.cpp b/backends/wince/pocketpc.cpp
new file mode 100644
index 0000000000..0162d14e28
--- /dev/null
+++ b/backends/wince/pocketpc.cpp
@@ -0,0 +1,1490 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#include "stdafx.h"
+#include <assert.h>
+
+#include "scumm.h"
+#include "debug.h"
+#include "screen.h"
+#include "gui.h"
+#include "sound/mididrv.h"
+#include "gameDetector.h"
+#include "simon/simon.h"
+#include "gapi_keys.h"
+#include "config-file.h"
+
+
+#include "commctrl.h"
+#include <Winuser.h>
+#include <Winnls.h>
+#include <sipapi.h>
+#include <Aygshell.h>
+#include <gx.h>
+#include <aygshell.h>
+#include "resource.h"
+
+#include "SDL.h"
+#include "SDL_audio.h"
+#include "SDL_timer.h"
+#include "SDL_thread.h"
+
+#define MAX(a,b) (((a)<(b)) ? (b) : (a))
+#define MIN(a,b) (((a)>(b)) ? (b) : (a))
+#define POCKETSCUMM_BUILD "080502"
+
+#define VERSION "Build " POCKETSCUMM_BUILD " (VM " SCUMMVM_CVS ")"
+
+typedef int (*tTimeCallback)(int);
+typedef void SoundProc(void *param, byte *buf, int len);
+
+GameDetector detector;
+Config *scummcfg;
+tTimeCallback timer_callback;
+int timer_interval;
+
+extern void Cls();
+
+extern BOOL isPrescanning();
+extern void changeScanPath();
+extern void startScan();
+extern void endScanPath();
+extern void abortScanPath();
+
+void load_key_mapping();
+void keypad_init();
+
+extern void Cls();
+
+extern BOOL isPrescanning();
+extern void changeScanPath();
+extern void startScan();
+extern void endScanPath();
+extern void abortScanPath();
+
+void keypad_init();
+
+class OSystem_WINCE3 : public OSystem {
+public:
+	// Set colors of the palette
+	void set_palette(const byte *colors, uint start, uint num);
+
+	// Set the size of the video bitmap.
+	// Typically, 320x200
+	void init_size(uint w, uint h);
+
+	// Draw a bitmap to screen.
+	// The screen will not be updated to reflect the new bitmap
+	void copy_rect(const byte *buf, int pitch, int x, int y, int w, int h);
+
+	// Update the dirty areas of the screen
+	void update_screen();
+
+	// Either show or hide the mouse cursor
+	bool show_mouse(bool visible);
+	
+	// Set the position of the mouse cursor
+	void set_mouse_pos(int x, int y);
+	
+	// Set the bitmap that's used when drawing the cursor.
+	void set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y);
+	
+	// Shaking is used in SCUMM. Set current shake position.
+	void set_shake_pos(int shake_pos);
+		
+	// Get the number of milliseconds since the program was started.
+	uint32 get_msecs();
+	
+	// Delay for a specified amount of milliseconds
+	void delay_msecs(uint msecs);
+	
+	// Create a thread
+	void *create_thread(ThreadProc *proc, void *param);
+	
+	// Get the next event.
+	// Returns true if an event was retrieved.	
+	bool poll_event(Event *event);
+	
+	// Set function that generates samples 
+	bool set_sound_proc(void *param, SoundProc *proc, byte sound);
+		
+	// Poll cdrom status
+	// Returns true if cd audio is playing
+	bool poll_cdrom();
+
+	// Play cdrom audio track
+	void play_cdrom(int track, int num_loops, int start_frame, int end_frame);
+
+	// Stop cdrom audio track
+	void stop_cdrom();
+
+	// Update cdrom audio status
+	void update_cdrom();
+
+	// Add a new callback timer
+	void set_timer(int timer, int (*callback)(int));
+
+	// Quit
+	void quit();
+
+	// Set a parameter
+	uint32 property(int param, Property *value);
+
+	static OSystem *create(int gfx_mode, bool full_screen);
+
+	// Added for hardware keys mapping
+
+	void addEventKeyPressed(int ascii_code);
+
+	void addEventRightButtonClicked();
+
+	// Mutex functions
+
+	void* create_mutex();
+	void lock_mutex(void*);
+	void unlock_mutex(void*);
+	void delete_mutex(void*);
+
+private:
+	// Windows callbacks & stuff
+	//bool handleMessage();
+	static LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+	
+
+	byte *_gfx_buf;
+	uint32 _start_time;
+	Event _event;
+	HMODULE hInst;
+	HWND hWnd;
+	bool _display_cursor;	
+
+	enum {
+		DF_FORCE_FULL_ON_PALETTE = 1,
+		DF_WANT_RECT_OPTIM = 2,
+		DF_2xSAI = 4,
+		DF_SEPARATE_HWSCREEN = 8,
+		DF_UPDATE_EXPAND_1_PIXEL = 16,
+	};
+
+	int _mode;
+	bool _full_screen;
+	bool _mouse_visible;
+	bool _mouse_drawn;
+	uint32 _mode_flags;
+
+	byte _internal_scaling;
+
+	bool force_full; //Force full redraw on next update_screen
+	bool cksum_valid;
+
+	enum {
+		NUM_DIRTY_RECT = 100,
+		SCREEN_WIDTH = 320,
+		SCREEN_HEIGHT = 200,
+		CKSUM_NUM = (SCREEN_WIDTH*SCREEN_HEIGHT/(8*8)),
+
+		MAX_MOUSE_W = 40,
+		MAX_MOUSE_H = 40,
+		MAX_SCALING = 3,
+
+		TMP_SCREEN_OFFS = 320*2 + 8,
+	};
+
+	/* CD Audio */
+	int cd_track, cd_num_loops, cd_start_frame, cd_end_frame;
+	Uint32 cd_end_time, cd_stop_time, cd_next_second;
+
+	struct MousePos {
+		int16 x,y,w,h;
+	};
+
+	byte *_ms_buf;
+	byte *_ms_backup;
+	MousePos _ms_cur;
+	MousePos _ms_old;
+	int16 _ms_hotspot_x;
+	int16 _ms_hotspot_y;
+	int _current_shake_pos;
+
+	
+	static void fill_sound(void *userdata, Uint8 * stream, int len);
+	
+
+	void draw_mouse();
+	void undraw_mouse();
+
+	void load_gfx_mode();
+	void unload_gfx_mode();
+
+	void hotswap_gfx_mode();
+
+	void get_320x200_image(byte *buf);
+};
+
+/************* WinCE Specifics *****************/
+byte veryFastMode;
+
+bool sound_activated, terminated;
+HWND hWnd_MainMenu;
+HWND hWnd_Window;
+
+void drawAllToolbar(bool);
+void redrawSoundItem();
+ToolbarSelected getToolbarSelection(int, int);
+
+extern bool toolbar_drawn;
+extern bool draw_keyboard;
+bool hide_toolbar;
+bool hide_cursor;
+
+bool get_key_mapping;
+static char _directory[MAX_PATH];
+
+SoundProc *real_soundproc;
+
+const char KEYBOARD_MAPPING_ALPHA_HIGH[] = {"ABCDEFGHIJKLM"};
+const char KEYBOARD_MAPPING_NUMERIC_HIGH[] = {"12345"};
+const char KEYBOARD_MAPPING_ALPHA_LOW[] = {"NOPQRSTUVWXYZ"};
+const char KEYBOARD_MAPPING_NUMERIC_LOW[] = {"67890"};
+
+extern void startFindGame();
+extern void displayGameInfo();
+extern bool loadGameSettings(void);
+extern void setFindGameDlgHandle(HWND);
+extern void getSelectedGame(int, char*, TCHAR*);
+
+extern void palette_update();
+
+extern void own_soundProc(void *buffer, byte *samples, int len);
+
+//#define SHMenuBar_GetMenu(hWndMB,ID_MENU) (HMENU)SendMessage((hWndMB), SHCMBM_GETSUBMENU, (WPARAM)0, (LPARAM)ID_MENU)
+
+/* Monkey2 keyboard stuff */
+bool monkey2_keyboard;
+
+void do_quit() {
+	scummcfg->set("Sound", sound_activated, "wince");
+	scummcfg->set("DisplayMode", GetScreenMode(), "wince");
+	scummcfg->flush();
+	GXCloseInput();
+	GXCloseDisplay();
+	SDL_AudioQuit();
+	exit(1);
+}
+
+void Error(LPCTSTR msg)
+{
+	OutputDebugString(msg);
+	MessageBox(HWND_DESKTOP, msg, TEXT("Error"), MB_ICONSTOP);
+	exit(1);
+}
+
+void Warning(LPCTSTR msg)
+{
+	OutputDebugString(msg);
+	MessageBox(HWND_DESKTOP, msg, TEXT("Error"), MB_ICONSTOP);	
+}
+
+int mapKey(int key) {
+	if (key>=VK_F1 && key<=VK_F9) {
+		return key - VK_F1 + 315;
+	}
+	return key;
+}
+
+BOOL CALLBACK SelectDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
+{
+	switch(uMsg)
+	{
+	case WM_INITDIALOG:
+		{
+			TCHAR work[1024];
+			RECT rc; GetWindowRect(hwndDlg, &rc);
+			MoveWindow(hwndDlg,
+				(GetSystemMetrics(SM_CXSCREEN)-rc.right+rc.left)/2,
+				(GetSystemMetrics(SM_CYSCREEN)-rc.bottom+rc.top)/2,
+				rc.right-rc.left, rc.bottom-rc.top, TRUE);
+			BringWindowToTop(hwndDlg);
+			setFindGameDlgHandle(hwndDlg);
+			MultiByteToWideChar(CP_ACP, 0, VERSION, strlen(VERSION) + 1, work, sizeof(work));
+			SetDlgItemText(hwndDlg, IDC_GAMEDESC, work);
+			loadGameSettings();
+		}
+		return TRUE;
+
+	case WM_COMMAND:
+
+		if (LOWORD(wParam) == IDC_LISTAVAILABLE && HIWORD(wParam) == LBN_SELCHANGE) {
+			if (!isPrescanning()) 
+				displayGameInfo();
+			else
+				changeScanPath();
+		}
+
+		if (wParam == IDC_SCAN) {
+			if (!isPrescanning()) 
+				startScan();
+			else
+				endScanPath();
+		}
+		
+		if (wParam == IDC_PLAY) {
+			int item;
+
+			item = SendMessage(GetDlgItem(hwndDlg, IDC_LISTAVAILABLE), LB_GETCURSEL, 0, 0);
+			if (item == LB_ERR) {
+				MessageBox(hwndDlg, TEXT("Please select a game"), TEXT("Error"), MB_OK);
+			}
+			else
+				EndDialog(hwndDlg, item + 1000);
+		}
+
+		if (wParam == IDC_EXIT) {
+			if (!isPrescanning()) 
+				EndDialog(hwndDlg, 0);	
+			else
+				abortScanPath();
+		}
+		return TRUE;
+	default:
+		return FALSE;
+	}
+}
+
+char* GameSelector()
+{
+	TCHAR directory[MAX_PATH];	
+	static char  id[100];
+
+	DWORD result = DialogBox(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_GAMESELECT), HWND_DESKTOP, SelectDlgProc);
+	if (result < 1000)
+		return NULL;
+	result -= 1000;
+
+	getSelectedGame(result, id, directory);
+
+	WideCharToMultiByte(CP_ACP, 0, directory, wcslen(directory) + 1, _directory, sizeof(_directory), NULL, NULL);
+
+	strcat(_directory, "\\");
+	
+	return id;
+	
+}
+
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nShowCmd)
+{
+	
+	int argc = 3;
+	char* argv[3];
+	char argdir[MAX_PATH];
+	char *game_name;
+	const char *sound;
+
+	hide_toolbar = false;
+
+	scummcfg = new Config("scummvm.ini", "scummvm");
+	scummcfg->set_writing(true);
+
+	sound = scummcfg->get("Sound", "wince");
+	if (sound) 
+		sound_activated = (atoi(sound) == 1);
+	else
+		sound_activated = true;
+
+	game_name = GameSelector();
+	if (!game_name)
+		return 0;
+
+	argv[0] = NULL;	
+	sprintf(argdir, "-p%s", _directory);
+	argv[1] = argdir;
+	argv[2] = game_name;
+
+	if (!argv[2])
+		return 0;
+
+	// No default toolbar for zak256
+	/*
+	if (strcmp(game_name, "zak256") == 0)
+		hide_toolbar = true;
+	*/
+
+	// Keyboard activated for Monkey Island 2
+	if (strcmp(game_name, "monkey2") == 0) {
+		draw_keyboard = true;
+		monkey2_keyboard = true;
+	}		
+
+	if (detector.detectMain(argc, argv))
+		return (-1);
+
+	OSystem *system = detector.createSystem();
+	
+	// Create the game engine
+	Engine *engine = Engine::createFromDetector(&detector, system);
+
+	keypad_init();
+	load_key_mapping();
+	
+	hide_cursor = TRUE;
+	if (detector._gameId == GID_SAMNMAX || detector._gameId == GID_FT || detector._gameId == GID_DIG)
+		hide_cursor = FALSE;
+
+	// Run the game engine
+	engine->go();
+	
+	return 0;
+}
+
+
+
+LRESULT CALLBACK OSystem_WINCE3::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+	static		 SHACTIVATEINFO sai;
+
+	OSystem_WINCE3 *wm = (OSystem_WINCE3*)GetWindowLong(hWnd, GWL_USERDATA);
+	
+	if (monkey2_keyboard && g_scumm->_vars[g_scumm->VAR_ROOM] != 108) {
+		monkey2_keyboard = false;
+		draw_keyboard = false;
+		toolbar_drawn = false;
+	}
+
+	switch (message) 
+	{
+	case WM_CREATE:
+		memset(&sai, 0, sizeof(sai));
+		SHSipPreference(hWnd, SIP_FORCEDOWN);
+//		SHSipPreference(hWnd, SIP_INPUTDIALOG);
+
+		return 0;
+
+	case WM_DESTROY:
+	case WM_CLOSE:
+		GraphicsOff();
+		PostQuitMessage(0);
+		break;
+
+	case WM_ERASEBKGND:
+		{
+			
+			RECT rc;
+			HDC hDC;
+			if (!GetScreenMode()) {
+				GetClientRect(hWnd, &rc);
+				rc.top = 200;
+				hDC = GetDC(hWnd);
+				if(rc.top < rc.bottom)
+					FillRect(hDC, &rc, (HBRUSH)GetStockObject(BLACK_BRUSH));
+				ReleaseDC(hWnd, hDC);			
+			}			
+		}
+		return 1;
+
+	case WM_PAINT:
+		{
+			HDC hDC;
+			PAINTSTRUCT ps;
+			hDC = BeginPaint (hWnd, &ps);
+			EndPaint (hWnd, &ps);
+			if (!hide_toolbar)
+				toolbar_drawn = false;
+
+			/*
+			if(!GetScreenMode()) {
+				SHSipPreference(hWnd, SIP_UP);
+			} else {
+				SHSipPreference(hWnd, SIP_FORCEDOWN);
+			} 
+			*/
+			SHSipPreference(hWnd, SIP_FORCEDOWN);
+		}
+//		SHSipPreference(hWnd, SIP_UP); /* Hack! */
+		/* It does not happen often but I don't want to see tooltip traces */
+		wm->update_screen();
+		return 0;
+
+	case WM_ACTIVATE:
+	case WM_SETFOCUS:	
+		GraphicsResume();
+		if (!hide_toolbar)
+			toolbar_drawn = false;
+//		SHHandleWMActivate(hWnd, wParam, lParam, &sai, SHA_INPUTDIALOG);
+
+		SHSipPreference(hWnd, SIP_FORCEDOWN);
+		SHFullScreen(hWnd, SHFS_HIDETASKBAR);
+		MoveWindow(hWnd, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), TRUE);
+		SetCapture(hWnd);
+		
+		/*
+		if (LOWORD(wParam) == WA_ACTIVE) {
+			if (GetScreenMode()) {		
+				SHSipPreference(hWnd, SIP_FORCEDOWN);
+				SHFullScreen(hWnd, SHFS_HIDETASKBAR);
+				MoveWindow(hWnd, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), TRUE);
+				SetCapture(hWnd);
+			}
+			else {
+				SHFullScreen(hWnd, SHFS_SHOWTASKBAR);
+				MoveWindow(hWnd, 0, 0, GetSystemMetrics(SM_CYSCREEN), GetSystemMetrics(SM_CXSCREEN), TRUE);
+			}
+		}
+		*/
+
+		return 0;
+
+	case WM_HIBERNATE:
+	case WM_KILLFOCUS:
+		GraphicsSuspend();
+		if (!hide_toolbar)
+			toolbar_drawn = false;
+		return 0;
+
+	case WM_SETTINGCHANGE:
+		SHHandleWMSettingChange(hWnd, wParam, lParam, &sai);
+		if (!hide_toolbar)
+			toolbar_drawn = false;
+		return 0;
+
+	
+	case WM_COMMAND:
+		/*
+		switch(wParam)
+		{
+		case IDC_OPTIONS:			
+			wm->_event.kbd.ascii = KEY_SET_OPTIONS;
+			wm->_event.event_code = EVENT_KEYDOWN;
+			break;
+		case IDC_EXIT:
+			DestroyWindow(hWnd);
+			do_quit();			
+			break;
+		case IDC_SKIP:
+			if (detector._gameId >= GID_SIMON_FIRST &&
+				detector._gameId <= GID_SIMON_LAST) {
+				g_simon->_exit_cutscene = true;
+				break;
+			}
+			if (g_scumm->vm.cutScenePtr[g_scumm->vm.cutSceneStackPointer])
+				wm->_event.kbd.ascii = g_scumm->_vars[g_scumm->VAR_CUTSCENEEXIT_KEY];
+			else
+				wm->_event.kbd.ascii = g_scumm->_vars[g_scumm->VAR_TALKSTOP_KEY];						
+			break;
+		case IDC_LOADSAVE:
+			if (detector._gameId >= GID_SIMON_FIRST &&
+				detector._gameId <= GID_SIMON_LAST) {
+				break;
+			}
+			if (GetScreenMode()) {
+				draw_keyboard = true;
+				if (!hide_toolbar)
+					toolbar_drawn = false;
+			}
+			wm->_event.kbd.ascii = mapKey(VK_F5);
+			wm->_event.event_code = EVENT_KEYDOWN;
+			break;
+		
+		case IDC_SOUND:
+			sound_activated = !sound_activated;
+			CheckMenuItem (
+				SHMenuBar_GetMenu (hWnd_MainMenu, IDM_POCKETSCUMM),
+				IDC_SOUND, 
+				MF_BYCOMMAND | (sound_activated ? MF_CHECKED : MF_UNCHECKED));	
+			if (detector._gameId >= GID_SIMON_FIRST &&
+				detector._gameId <= GID_SIMON_LAST) {
+				g_mixer->pause(!sound_activated);
+			}
+			else
+				g_scumm->pauseSounds(!sound_activated);
+
+			break;     
+		
+      break;
+
+		case IDC_LANDSCAPE:
+			//HWND taskbar;
+			//SHFullScreen (hWnd, SHFS_HIDESIPBUTTON | SHFS_HIDETASKBAR | SHFS_HIDESTARTICON);
+			//InvalidateRect(HWND_DESKTOP, NULL, TRUE);
+			SetScreenMode(!GetScreenMode());
+			//SHSipPreference(hWnd,SIP_FORCEDOWN);
+			//MoveWindow(hWnd, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), TRUE);
+			//SetCapture(hWnd); // to prevent input panel from getting taps						
+			/*taskbar = FindWindow(TEXT("HHTaskBar"), NULL);
+			if (taskbar)
+				ShowWindow(taskbar, SW_HIDE);*/
+			/*SHSipPreference(hWnd, SIP_FORCEDOWN);
+			SHFullScreen(hWnd, SHFS_HIDETASKBAR);*/
+		/*
+			SetForegroundWindow(hWnd);
+			MoveWindow(hWnd, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), TRUE);
+			SetCapture(hWnd);
+			UpdateWindow(hWnd);
+			if (!hide_toolbar)
+				toolbar_drawn = false;
+			break;
+
+		}
+		*/
+		
+		return 0;
+	
+	case WM_KEYDOWN:
+		if(wParam && wParam != 0x84) { // WHAT THE ???			
+
+			/*
+			unsigned char GAPI_key;
+
+			GAPI_key = getGAPIKeyMapping((short)wParam);
+			if (GAPI_key) {
+			*/
+				if (get_key_mapping) {
+					wm->_event.kbd.ascii = GAPI_KEY_BASE + GAPIKeysTranslate((int)wParam);
+					wm->_event.event_code = EVENT_KEYDOWN;
+					break;
+				}					
+				/*
+				else
+					processAction((short)wParam);
+				*/
+			/*}*/
+			if (!processAction(GAPIKeysTranslate((int)wParam)))
+			/*else*/ {
+				wm->_event.kbd.ascii = mapKey(wParam);
+				wm->_event.event_code = EVENT_KEYDOWN;								
+			}
+		}
+
+		break;
+
+	case WM_KEYUP:
+		break;
+
+	case WM_MOUSEMOVE:
+		{
+			int x = ((int16*)&lParam)[0];
+			int y = ((int16*)&lParam)[1];
+			Translate(&x, &y);
+			wm->_event.event_code = EVENT_MOUSEMOVE;
+			wm->_event.mouse.x = x;
+			wm->_event.mouse.y = y;
+		}
+		break;
+	case WM_LBUTTONDOWN:
+		{
+			ToolbarSelected toolbar_selection;
+			int x = ((int16*)&lParam)[0];
+			int y = ((int16*)&lParam)[1];
+			
+			//FILE *toto;
+			
+			Translate(&x, &y);
+
+			/*
+ 			fprintf(toto, "Non translated %d %d Translated %d %d\n",
+					((int16*)&lParam)[0], ((int16*)&lParam)[1],
+					x, y);
+			fclose(toto);
+			*/
+
+
+			if (draw_keyboard) {
+				// Handle keyboard selection
+				int offset_y;
+				int saved_x = x;
+				int saved_y = y;
+
+				/*
+				if (!GetScreenMode()) {
+					x = ((int16*)&lParam)[0];
+					y = ((int16*)&lParam)[1];
+				}
+				*/
+
+				offset_y = (GetScreenMode() ? 0 : 40 + 22);
+
+				if (x<185 && y>=(200 + offset_y)) {
+					//Alpha selection
+					wm->_event.event_code = EVENT_KEYDOWN;
+					wm->_event.kbd.ascii = 
+						(y <= (220 + offset_y)? KEYBOARD_MAPPING_ALPHA_HIGH[((x + 10) / 14) - 1] :
+												KEYBOARD_MAPPING_ALPHA_LOW[((x + 10) / 14) - 1]);
+					break;
+				} 
+				else
+				if (x>=186 && y>=(200 + offset_y) && x<=255) {
+				   // Numeric selection
+				   wm->_event.event_code = EVENT_KEYDOWN;
+				   wm->_event.kbd.ascii =
+					   (y <= (220 + offset_y) ? KEYBOARD_MAPPING_NUMERIC_HIGH[((x - 187 + 10) / 14) - 1] :
+												KEYBOARD_MAPPING_NUMERIC_LOW[((x - 187 + 10) / 14) - 1]);
+				   break;
+				}
+				else
+				if (x>=302 && x <= 316 && y >= (200 + offset_y) && y <= (220 + offset_y)) {
+				  // Backspace
+				  wm->_event.event_code = EVENT_KEYDOWN;
+				  wm->_event.kbd.ascii = mapKey(VK_BACK);
+				  break;
+				}
+				else
+				if (x>=302 && x<= 316 && y >= (220 + offset_y)) { 
+				  // Enter
+				  wm->_event.event_code = EVENT_KEYDOWN;
+				  wm->_event.kbd.ascii = mapKey(VK_RETURN);
+				  break;
+				}
+
+				x = saved_x;
+				y = saved_y;
+
+				wm->_event.event_code = EVENT_LBUTTONDOWN;
+				wm->_event.mouse.x = x;
+				wm->_event.mouse.y = y;
+				break;
+
+			}
+					
+
+			toolbar_selection = (hide_toolbar || get_key_mapping ? ToolbarNone : 
+									 getToolbarSelection(
+										 (GetScreenMode() ? x : ((int16*)&lParam)[0]), 
+										 (GetScreenMode() ? y : ((int16*)&lParam)[1])));
+			if (toolbar_selection == ToolbarNone) {				
+				wm->_event.event_code = EVENT_LBUTTONDOWN;
+				wm->_event.mouse.x = x;
+				wm->_event.mouse.y = y;
+			
+				/*
+				if(y > 200 && !hide_toolbar)
+				{
+					if(x<160) {
+					   wm->_event.event_code = EVENT_KEYDOWN;
+					   wm->_event.kbd.ascii = mapKey(VK_ESCAPE);
+					}
+					else
+					{
+						HDC hDC;
+						PAINTSTRUCT ps;
+
+						SetScreenMode(0); // restore normal tap logic
+						//SHSipPreference(hWnd,SIP_UP);
+						ReleaseCapture();
+						//InvalidateRect(HWND_DESKTOP, NULL, TRUE);		
+						SHFullScreen(hWnd, SHFS_HIDESIPBUTTON | SHFS_HIDETASKBAR | SHFS_HIDESTARTICON);
+						MoveWindow(hWnd, 0, 0, GetSystemMetrics(SM_CYSCREEN), GetSystemMetrics(SM_CXSCREEN), TRUE);
+						SetWindowPos(hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
+						SetForegroundWindow(hWnd);						
+						hDC = BeginPaint (hWnd, &ps);
+						EndPaint (hWnd, &ps);
+					}				
+				}
+				*/
+			}
+			else {
+				switch(toolbar_selection) {
+					case ToolbarSaveLoad:
+						if (detector._gameId >= GID_SIMON_FIRST &&
+							detector._gameId <= GID_SIMON_LAST) {							
+							break;
+						}
+						/*if (GetScreenMode()) {*/
+						/*
+							draw_keyboard = true;
+							if (!hide_toolbar)
+								toolbar_drawn = false;
+						*/
+						/*}*/
+						wm->_event.event_code = EVENT_KEYDOWN;
+						wm->_event.kbd.ascii = mapKey(VK_F5);
+						break;
+					case ToolbarMode:
+						SetScreenMode(!GetScreenMode());
+						if (!hide_toolbar)
+							toolbar_drawn = false;
+						break;
+					case ToolbarSkip:
+						if (detector._gameId >= GID_SIMON_FIRST &&
+							detector._gameId <= GID_SIMON_LAST) {							
+							// Fake a right click to abort the current cut scene
+							wm->_event.event_code = EVENT_RBUTTONDOWN;
+							wm->_event.mouse.x = x;
+							wm->_event.mouse.y = y;
+							break;
+						}
+						wm->_event.event_code = EVENT_KEYDOWN;
+						if (g_scumm->vm.cutScenePtr[g_scumm->vm.cutSceneStackPointer])
+							wm->_event.kbd.ascii = g_scumm->_vars[g_scumm->VAR_CUTSCENEEXIT_KEY];
+						else
+							wm->_event.kbd.ascii = g_scumm->_vars[g_scumm->VAR_TALKSTOP_KEY];						
+						break;
+					case ToolbarSound:
+						sound_activated = !sound_activated;
+						redrawSoundItem();
+						break;
+					default:
+						break;
+				}
+			}
+		}
+		break;
+	case WM_LBUTTONUP:
+		{
+			// pinched from the SDL code. Distinguishes between taps and not
+			int x = ((int16*)&lParam)[0];
+			int y = ((int16*)&lParam)[1];
+			Translate(&x, &y);
+			wm->_event.event_code = EVENT_LBUTTONUP;
+			wm->_event.mouse.x = x;
+			wm->_event.mouse.y = y;
+		}
+		break;
+	case WM_LBUTTONDBLCLK:  // doesn't seem to work right now
+		//wm->_scumm->_rightBtnPressed |= msClicked | msDown;
+		break;
+	case WM_TIMER:
+		timer_callback(timer_interval);
+		break;
+	default:
+		return DefWindowProc(hWnd, message, wParam, lParam);
+   }
+   return 0;
+}
+
+/*************** Specific config support ***********/
+
+void load_key_mapping() {
+	 unsigned char actions[NUMBER_ACTIONS];
+	 int actions_keys[NUMBER_ACTIONS];
+	 const char		*current;
+	 const char		*version;
+	 int			i;
+	 
+	 memset(actions_keys, 0, sizeof(actions_keys));
+	 
+	 version = scummcfg->get("KeysVersion", "wince");
+
+	 current = scummcfg->get("ActionKeys", "wince");
+	 if (current && version) {
+		for (i=0; i<NUMBER_ACTIONS; i++) {
+			char x[6];
+			int j;
+
+			memset(x, 0, sizeof(x));
+			memcpy(x, current + 5 * i, 4);
+			sscanf(x, "%x", &j);
+			actions_keys[i] = j;
+		}
+	 }
+	 setActionKeys(actions_keys);
+
+	 memset(actions, 0, NUMBER_ACTIONS);
+
+	 actions[0] = ACTION_PAUSE;
+	 actions[1] = ACTION_SAVE;
+	 actions[2] = ACTION_BOSS;
+	 actions[3] = ACTION_SKIP;
+	 actions[4] = ACTION_HIDE;
+
+	 current = scummcfg->get("ActionTypes", "wince");
+	 if (current && version) {
+		for (i=0; i<NUMBER_ACTIONS; i++) {
+			char x[6];
+			int j;
+
+			memset(x, 0, sizeof(x));
+			memcpy(x, current + 3 * i, 2);
+			sscanf(x, "%x", &j);
+			actions[i] = j;
+		}
+	 }
+	 setActionTypes(actions);
+
+	 if (!version) {
+		 scummcfg->set("KeysVersion", "2", "wince");
+		 scummcfg->flush();
+	 }
+}
+					
+void save_key_mapping() {
+	 char tempo[1024];
+	 const int *work_keys;
+	 const unsigned char *work;
+	 int i;
+
+	 tempo[0] = '\0';
+	 work_keys = getActionKeys();
+	 for (i=0; i<NUMBER_ACTIONS; i++) {
+		 char x[4];
+		 sprintf(x, "%.4x ", work_keys[i]);
+		 strcat(tempo, x);
+	 }
+	 scummcfg->set("ActionKeys", tempo, "wince");
+	 tempo[0] = '\0';
+	 work = getActionTypes();
+	 for (i=0; i<NUMBER_ACTIONS; i++) {
+		 char x[3];
+		 sprintf(x, "%.2x ", work[i]);
+		 strcat(tempo, x);
+	 }
+	 scummcfg->set("ActionTypes", tempo, "wince");
+
+	 scummcfg->flush();
+}
+
+/*************** Hardware keys support ***********/
+
+void OSystem_WINCE3::addEventKeyPressed(int ascii_code) {
+	_event.event_code = EVENT_KEYDOWN;
+	_event.kbd.ascii = ascii_code;
+}
+
+void OSystem_WINCE3::addEventRightButtonClicked() {
+	OSystem_WINCE3* system;
+	system = (OSystem_WINCE3*)g_scumm->_system;
+	
+	system->addEventKeyPressed(9);
+}
+
+void action_right_click() {
+	OSystem_WINCE3* system;
+	system = (OSystem_WINCE3*)g_scumm->_system;
+
+	system->addEventRightButtonClicked();	
+}
+
+void action_pause() {
+	OSystem_WINCE3* system;
+	system = (OSystem_WINCE3*)g_scumm->_system;
+
+	system->addEventKeyPressed(mapKey(VK_SPACE));
+}
+
+void action_save() {
+	OSystem_WINCE3* system;
+	system = (OSystem_WINCE3*)g_scumm->_system;
+
+	/*if (GetScreenMode()) {*/
+	/*
+		draw_keyboard = true;
+		if (!hide_toolbar)
+			toolbar_drawn = false;
+	*/
+	/*}*/
+
+	system->addEventKeyPressed(mapKey(VK_F5));
+}
+
+void action_quit() {
+	do_quit();
+}
+
+void action_boss() {
+	SHELLEXECUTEINFO se;    
+
+	scummcfg->set("Sound", sound_activated, "wince");
+	scummcfg->set("DisplayMode", GetScreenMode(), "wince");
+	scummcfg->flush();
+	sound_activated = false;
+	toolbar_drawn = false;
+	hide_toolbar = true;
+	Cls();
+	g_scumm->_saveLoadSlot = 0;
+	g_scumm->_saveLoadCompatible = false;
+	g_scumm->_saveLoadFlag = 1;
+	strcpy(g_scumm->_saveLoadName, "BOSS");
+	g_scumm->saveState(g_scumm->_saveLoadSlot, g_scumm->_saveLoadCompatible);
+	GXCloseInput();
+	GXCloseDisplay();
+	SDL_AudioQuit();
+	memset(&se, 0, sizeof(se));
+	se.cbSize = sizeof(se);
+	se.hwnd = NULL;
+	se.lpFile = TEXT("tasks.exe");
+	se.lpVerb = TEXT("open");
+	se.lpDirectory = TEXT("\\windows");
+	ShellExecuteEx(&se);
+	exit(1);
+}
+
+void action_skip() {
+	OSystem_WINCE3* system;
+	system = (OSystem_WINCE3*)g_scumm->_system;
+
+	if (g_scumm->vm.cutScenePtr[g_scumm->vm.cutSceneStackPointer])
+		system->addEventKeyPressed(g_scumm->_vars[g_scumm->VAR_CUTSCENEEXIT_KEY]);
+	else
+		system->addEventKeyPressed(g_scumm->_vars[g_scumm->VAR_TALKSTOP_KEY]);						
+}
+
+void do_hide(bool hide_state) {
+	hide_toolbar = hide_state;
+	if (hide_toolbar)
+		RestoreScreenGeometry();
+	else
+		LimitScreenGeometry();
+	Cls();
+	toolbar_drawn = hide_toolbar;
+	g_scumm->_system->update_screen();
+}
+
+void action_hide() {
+	do_hide(!hide_toolbar);
+}
+
+void action_keyboard() {
+	/*if (GetScreenMode()) {*/
+		draw_keyboard = !draw_keyboard;
+		if (!hide_toolbar)
+			toolbar_drawn = false;
+	/*}*/
+}
+
+void action_sound() {
+	sound_activated = !sound_activated;
+}
+
+void action_cursoronoff() {
+	hide_cursor = !hide_cursor;
+}
+
+void action_subtitleonoff() {
+	g_scumm->_noSubtitles = !g_scumm->_noSubtitles;
+}
+
+void keypad_init() {
+	static pAction actions[TOTAL_ACTIONS] =
+	{ action_pause, action_save, action_quit, action_skip, action_hide, 
+	  action_keyboard, action_sound, action_right_click, action_cursoronoff,
+	  action_subtitleonoff, action_boss
+	};
+	
+	GAPIKeysInit(actions);
+	
+}
+
+void keypad_close() {
+	GXCloseInput();	
+}
+
+
+/************* OSystem Main **********************/
+OSystem *OSystem_WINCE3::create(int gfx_mode, bool full_screen) {
+	const char *display_mode;
+	OSystem_WINCE3 *syst = new OSystem_WINCE3();
+	syst->_mode = gfx_mode;
+	syst->_full_screen = full_screen;
+	syst->_event.event_code = -1;
+	syst->_start_time = GetTickCount();
+
+	/* Retrieve the handle of this module */
+	syst->hInst = GetModuleHandle(NULL);
+
+	/* Register the window class */
+	WNDCLASS wcex;
+	wcex.style			= CS_HREDRAW | CS_VREDRAW;
+	wcex.lpfnWndProc	= (WNDPROC)WndProc;
+	wcex.cbClsExtra		= 0;
+	wcex.cbWndExtra		= 0;
+	wcex.hInstance		= syst->hInst;
+	wcex.hIcon			= 0;
+	wcex.hCursor		= NULL;
+	wcex.hbrBackground	= (HBRUSH)GetStockObject(BLACK_BRUSH);
+	wcex.lpszMenuName	= 0;	
+	wcex.lpszClassName	= TEXT("ScummVM");
+	if (!RegisterClass(&wcex))
+		Error(TEXT("Cannot register window class!"));
+
+	syst->hWnd = CreateWindow(TEXT("ScummVM"), TEXT("ScummVM"), WS_VISIBLE,
+      0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN), NULL, NULL, syst->hInst, NULL);
+	hWnd_Window = syst->hWnd;
+	SetWindowLong(syst->hWnd, GWL_USERDATA, (long)syst);
+
+	ShowWindow(syst->hWnd, SW_SHOW);
+	UpdateWindow(syst->hWnd);
+
+	/*
+	SHMENUBARINFO smbi;
+	smbi.cbSize = sizeof(smbi); 
+	smbi.hwndParent = syst->hWnd; 
+	smbi.dwFlags = 0; 
+	smbi.nToolBarId = IDM_MENU; 
+	smbi.hInstRes = GetModuleHandle(NULL); 
+	smbi.nBmpId = 0; 
+	smbi.cBmpImages = 0; 
+	smbi.hwndMB = NULL;
+	BOOL res = SHCreateMenuBar(&smbi);
+	hWnd_MainMenu = smbi.hwndMB;
+	*/
+
+	/* Sound is activated on default - initialize it in the menu */
+	/*
+	CheckMenuItem((HMENU)SHMenuBar_GetMenu (hWnd_MainMenu, IDM_POCKETSCUMM),
+		IDC_SOUND, MF_BYCOMMAND | MF_CHECKED);
+	*/
+
+	GraphicsOn(syst->hWnd);
+
+	SetWindowPos(syst->hWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
+	SetForegroundWindow(syst->hWnd);
+	SHFullScreen(syst->hWnd, SHFS_HIDESIPBUTTON | SHFS_HIDETASKBAR | SHFS_HIDESTARTICON);
+
+	
+	// Mini SDL init
+
+	if (SDL_Init(SDL_INIT_AUDIO)==-1) {		
+	    exit(1);
+	}
+
+	Cls();
+	drawWait();
+
+	// Set mode, portrait or landscape
+	display_mode = scummcfg->get("DisplayMode", "wince");
+	if (display_mode)
+		SetScreenMode(atoi(display_mode));
+
+	return syst;
+}
+
+OSystem *OSystem_WINCE3_create() {
+	return OSystem_WINCE3::create(0, 0);
+}
+
+void OSystem_WINCE3::set_timer(int timer, int (*callback)(int)) {
+	SetTimer(hWnd, 1, timer, NULL);
+	timer_interval = timer;
+	timer_callback = callback;
+}
+
+void OSystem_WINCE3::set_palette(const byte *colors, uint start, uint num) {
+	const byte *b = colors;
+	uint i;
+	for(i=0;i!=num;i++) {
+		SetPalEntry(i + start, b[0], b[1], b[2]);
+		b += 4;
+	}
+
+	palette_update();
+}
+
+void OSystem_WINCE3::load_gfx_mode() {
+	force_full = true;
+
+	_gfx_buf = (byte*)malloc((320 * 240) * sizeof(byte));	
+	_ms_backup = (byte*)malloc((40 * 40 * 3) * sizeof(byte));
+}
+
+void OSystem_WINCE3::unload_gfx_mode() {
+ // FIXME: Free the _gfx_buf here
+}
+
+void OSystem_WINCE3::init_size(uint w, uint h) {
+	load_gfx_mode();
+	SetScreenGeometry(w, h);
+}
+
+void OSystem_WINCE3::copy_rect(const byte *buf, int pitch, int x, int y, int w, int h) {
+	byte *dst;
+
+	if (!hide_cursor && _mouse_drawn)
+		undraw_mouse();
+
+	dst = _gfx_buf + y * 320 + x;
+	do {
+		memcpy(dst, buf, w);
+		dst += 320;
+		buf += pitch;
+	} while (--h);
+}
+
+void OSystem_WINCE3::update_screen() {
+
+	if (!hide_cursor)
+		draw_mouse();
+
+	Blt(_gfx_buf);
+}
+
+bool OSystem_WINCE3::show_mouse(bool visible) {
+	if (_mouse_visible == visible)
+		return visible;
+	
+	bool last = _mouse_visible;
+	_mouse_visible = visible;
+
+	return last;
+}
+
+// From X11 port
+
+void OSystem_WINCE3::draw_mouse() {
+	if (_mouse_drawn || !_mouse_visible)
+		return;
+	_mouse_drawn = true;
+
+	int xdraw = _ms_cur.x - _ms_hotspot_x;
+	int ydraw = _ms_cur.y - _ms_hotspot_y;
+	int w = _ms_cur.w;
+	int h = _ms_cur.h;
+	int real_w;
+	int real_h;
+	int real_h_2;
+
+	byte *dst;
+	byte *dst2;
+	const byte *buf = _ms_buf;
+	byte *bak = _ms_backup;
+
+	assert(w <= 40 && h <= 40);
+
+	if (ydraw < 0) {
+		real_h = h + ydraw;
+		buf += (-ydraw) * w;
+		ydraw = 0;
+	} else {
+		real_h = (ydraw + h) > 200 ? (200 - ydraw) : h;
+	}
+	if (xdraw < 0) {
+		real_w = w + xdraw;
+		buf += (-xdraw);
+		xdraw = 0;
+	} else {
+		real_w = (xdraw + w) > 320 ? (320 - xdraw) : w;
+	}
+
+	dst = _gfx_buf + (ydraw * 320) + xdraw;
+	dst2 = dst;
+
+	if ((real_h == 0) || (real_w == 0)) {
+		_mouse_drawn = false;
+		return;
+	}
+
+	_ms_old.x = xdraw;
+	_ms_old.y = ydraw;
+	_ms_old.w = real_w;
+	_ms_old.h = real_h;
+
+	real_h_2 = real_h;
+	while (real_h_2 > 0) {
+		memcpy(bak, dst, real_w);
+		bak += 40;
+		dst += 320;
+		real_h_2--;
+	}
+	while (real_h > 0) {
+		int width = real_w;
+		while (width > 0) {
+			byte color = *buf;
+			if (color != 0xFF) {
+				*dst2 = color;
+			}
+			buf++;
+			dst2++;
+			width--;
+		}
+		buf += w - real_w;
+		dst2 += 320 - real_w;
+		real_h--;
+	}
+}
+
+void OSystem_WINCE3::undraw_mouse() {
+	if (!_mouse_drawn)
+		return;
+	_mouse_drawn = false;
+
+	int old_h = _ms_old.h;
+
+	byte *dst = _gfx_buf + (_ms_old.y * 320) + _ms_old.x;
+	byte *bak = _ms_backup;
+
+	while (old_h > 0) {
+		memcpy(dst, bak, _ms_old.w);
+		bak += 40;
+		dst += 320;
+		old_h--;
+	}
+}
+
+	
+void OSystem_WINCE3::set_mouse_pos(int x, int y) {
+	if (x != _ms_cur.x || y != _ms_cur.y) {
+		_ms_cur.x = x;
+		_ms_cur.y = y;
+	}
+}
+	
+void OSystem_WINCE3::set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y) {
+	_ms_cur.w = w;
+	_ms_cur.h = h;
+
+	_ms_hotspot_x = hotspot_x;
+	_ms_hotspot_y = hotspot_y;
+
+	_ms_buf = (byte*)buf;
+
+	// Refresh mouse cursor
+
+	if (!hide_cursor) {
+		undraw_mouse();
+		draw_mouse();
+	}
+}
+	
+void OSystem_WINCE3::set_shake_pos(int shake_pos) {;}
+		
+uint32 OSystem_WINCE3::get_msecs() {
+	return GetTickCount() - _start_time;
+}
+	
+void OSystem_WINCE3::delay_msecs(uint msecs) {
+	//handleMessage();
+	Sleep(msecs);
+}
+	
+void *OSystem_WINCE3::create_thread(ThreadProc *proc, void *param) {
+	// needed for emulated MIDI support (Sam'n'Max)
+	return CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)proc, param, 0, NULL);
+}
+
+int mapKey(int key, byte mod)
+{
+	if (key>=VK_F1 && key<=VK_F9) {
+		return key - VK_F1 + 315;
+	}
+	return key;
+}
+	
+bool OSystem_WINCE3::poll_event(Event *event) {
+
+	for (;;) {
+		MSG msg;
+
+		_event.event_code = -1;
+
+		if (!PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
+			return false;
+
+		if (msg.message==WM_QUIT) {
+			terminated=true;
+			do_quit();
+			return false;
+		}
+
+		TranslateMessage(&msg);
+		DispatchMessage(&msg);
+
+		*event = _event;
+
+		return true;
+	}
+	
+	return false;
+}
+	
+void own_soundProc(void *buffer, byte *samples, int len) {
+
+	(*real_soundproc)(buffer, samples, len);
+
+	if (!sound_activated)
+		memset(samples, 0, len);
+}
+
+bool OSystem_WINCE3::set_sound_proc(void *param, SoundProc *proc, byte format) {
+	SDL_AudioSpec desired;
+
+	/* only one format supported at the moment */
+
+	real_soundproc = proc;
+	desired.freq = SAMPLES_PER_SEC;
+	desired.format = AUDIO_S16SYS;
+	desired.channels = 2;
+	desired.samples = 128;
+	desired.callback = own_soundProc;
+	desired.userdata = param;
+	if (SDL_OpenAudio(&desired, NULL) != 0) {
+		return false;
+	}
+	SDL_PauseAudio(0);
+	return true;
+}
+
+/* Hotswap graphics modes */
+void OSystem_WINCE3::get_320x200_image(byte *buf) {;}
+void OSystem_WINCE3::hotswap_gfx_mode() {;}
+uint32 OSystem_WINCE3::property(int param, Property *value) {
+	switch(param) {
+
+	case PROP_TOGGLE_FULLSCREEN:
+		return 1;
+
+	case PROP_SET_WINDOW_CAPTION:
+		return 1;
+
+	case PROP_OPEN_CD:		
+		break;
+
+	case PROP_SET_GFX_MODE:
+		return 1;
+
+	case PROP_SHOW_DEFAULT_CURSOR:
+		break;
+
+	case PROP_GET_SAMPLE_RATE:
+		return SAMPLES_PER_SEC;
+	}
+
+	return 0;
+}
+		
+void OSystem_WINCE3::quit() {
+	unload_gfx_mode();		
+	exit(1);
+}
+
+/* CDRom Audio */
+void OSystem_WINCE3::stop_cdrom() {;}
+void OSystem_WINCE3::play_cdrom(int track, int num_loops, int start_frame, int end_frame) {
+	/* Reset sync count */
+	g_scumm->_vars[g_scumm->VAR_MI1_TIMER] = 0;
+}
+
+bool OSystem_WINCE3::poll_cdrom() {return 0;}
+void OSystem_WINCE3::update_cdrom() {;}
+
+void ScummDebugger::attach(Scumm *s) {;}
+
+/* Mutex stuff */
+void* OSystem_WINCE3::create_mutex() {
+	return (void*)CreateMutex(NULL, FALSE, NULL);
+}
+void OSystem_WINCE3::lock_mutex(void *handle) {
+	WaitForSingleObject((HANDLE)handle, INFINITE);
+}
+
+void OSystem_WINCE3::unlock_mutex(void *handle) {
+	ReleaseMutex((HANDLE)handle);
+}
+
+void OSystem_WINCE3::delete_mutex(void *handle) {
+	CloseHandle((HANDLE)handle);
+}
\ No newline at end of file
diff --git a/backends/wince/pocketscumm.ico b/backends/wince/pocketscumm.ico
new file mode 100644
index 0000000000..1bc0dae683
--- /dev/null
+++ b/backends/wince/pocketscumm.ico
diff --git a/backends/wince/resource.h b/backends/wince/resource.h
new file mode 100644
index 0000000000..d0099cbc86
--- /dev/null
+++ b/backends/wince/resource.h
@@ -0,0 +1,58 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Developer Studio generated include file.
+// Used by PocketSCUMM.rc
+//
+#define IDD_GAMESELECT                  105
+#define IDD_SOUND_DIALOG                106
+#define IDB_SKIP                        113
+#define IDB_DISK                        115
+#define IDB_EXIT                        116
+#define IDB_SOUND_ON                    117
+#define IDB_SOUND_OFF                   118
+#define IDB_PANEL                       119
+#define IDI_POCKETSCUMM                 127
+#define IDB_KEYBOARD                    129
+#define IDL_POCKETSCUMM                 130
+#define IDB_MENUTITLE                   133
+#define IDD_DIALOG1                     134
+#define IDM_MENU                        1000
+#define IDC_ABOUT                       1000
+#define IDC_MONKEY                      1000
+#define IDC_OPTIONS                     1000
+#define IDC_EXIT                        1001
+#define IDC_MONKEY2                     1001
+#define IDD_SLIDERMUSIC                 1001
+#define IDC_ATLANTIS                    1002
+#define IDD_SLIDERSFX                   1002
+#define IDC_PLAYFATE                    1003
+#define IDC_TENTACLE                    1004
+#define IDC_DOTTDEMO                    1005
+#define IDC_SAMNMAX                     1006
+#define IDC_SNMDEMO                     1007
+#define IDC_DISABLE_SOUND               1008
+#define IDC_SLOW_SOUND                  1009
+#define IDC_FT                          1010
+#define IDC_LISTAVAILABLE               1011
+#define IDC_GAMEDESC                    1014
+#define IDC_PLAY                        1015
+#define IDC_FILEPATH                    1016
+#define IDC_SCAN                        1018
+#define ID_POCKETSCUMM                  40005
+#define IDS_CAP_POCKETSCUMM             40006
+#define IDC_LANDSCAPE                   40007
+#define IDC_SKIP                        40008
+#define IDC_LOADSAVE                    40009
+#define IDC_SOUND                       40011
+#define IDC_SOUNDVOL                    40012
+#define IDM_POCKETSCUMM                 40013
+
+// Next default values for new objects
+// 
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE        135
+#define _APS_NEXT_COMMAND_VALUE         40014
+#define _APS_NEXT_CONTROL_VALUE         1016
+#define _APS_NEXT_SYMED_VALUE           101
+#endif
+#endif
diff --git a/backends/wince/screen.cpp b/backends/wince/screen.cpp
new file mode 100644
index 0000000000..7dac8759ba
--- /dev/null
+++ b/backends/wince/screen.cpp
@@ -0,0 +1,1588 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+#ifdef _WIN32_WCE
+
+/* Original GFX code by Vasyl Tsvirkunov */
+
+#include <windows.h>
+#include <Aygshell.h>
+#include "gx.h"
+#include "screen.h"
+#include "resource.h"
+
+#define COLORCONV565(r,g,b) \
+(((r&0xf8)<<(11-3))|((g&0xfc)<<(5-2))|((b&0xf8)>>3))
+#define COLORCONV555(r,g,b) \
+(((r&0xf8)<<(10-3))|((g&0xf8)<<(5-2))|((b&0xf8)>>3))
+#define COLORCONVMONO(r,g,b) ((((3*r>>3)+(g>>1)+(b>>3))>>colorscale)^invert)
+
+#define MAX_CLR         0x100
+static UBYTE palRed[MAX_CLR];
+static UBYTE palGreen[MAX_CLR];
+static UBYTE palBlue[MAX_CLR];
+static unsigned short pal[MAX_CLR];
+ /* First 10 and last 10 colors on palettized devices require special treatment */
+static UBYTE staticTranslate[20];
+static UBYTE invert = 0;
+static int colorscale = 0;
+
+extern UBYTE item_toolbar[];
+extern UBYTE item_toolbar_colors[];
+extern UBYTE item_toolbarPortrait[];
+extern UBYTE item_toolbarPortrait_colors[];
+extern UBYTE item_keyboard[];
+extern UBYTE item_keyboard_colors[];
+extern UBYTE item_keyboardPortrait[];
+extern UBYTE item_keyboardPortrait_colors[];
+extern UBYTE item_disk[];
+extern UBYTE item_disk_colors[];
+extern UBYTE item_skip[];
+extern UBYTE item_skip_colors[];
+extern UBYTE item_soundOn[];
+extern UBYTE item_soundOn_colors[];
+extern UBYTE item_soundOff[];
+extern UBYTE item_soundOff_colors[];
+extern UBYTE item_monkeyLandscape[];
+extern UBYTE item_monkeyLandscape_colors[];
+extern UBYTE item_monkeyPortrait[];
+extern UBYTE item_monkeyPortrait_colors[];
+extern UBYTE item_loading[];
+extern UBYTE item_loading_colors[];
+
+
+extern bool sound_activated;
+extern bool hide_toolbar;
+bool toolbar_drawn;
+bool draw_keyboard;
+
+GXDisplayProperties gxdp;
+int active;
+
+struct tScreenGeometry
+{
+	long width;
+	long height;
+	long startoffset;
+	long sourceoffset;
+	long linestep;
+	long pixelstep;
+	long xSkipMask;
+	long xLimit;
+	long lineLimit;
+};
+
+
+tScreenGeometry geom[3];
+
+int currentScreenMode = 0;
+int useMode = 0;
+int maxMode = 2;
+int filter_available;
+int smooth_filter;
+int toolbar_available;
+
+UBYTE *toolbar = NULL;
+
+/* Using vectorized function to save on branches */
+typedef void (*tCls)();
+typedef void (*tBlt)(UBYTE*);
+typedef void (*tBlt_part)(UBYTE*,int, int, int, int, UBYTE*);
+
+void mono_Cls();
+void mono_Blt(UBYTE*);
+void mono_Blt_part(UBYTE*, int, int, int, int, UBYTE*);
+
+void palette_Cls();
+void palette_Blt(UBYTE*);
+void palette_Blt_part(UBYTE*, int, int, int, int, UBYTE*);
+
+void hicolor_Cls();
+void hicolor555_Blt(UBYTE*);
+void hicolor555_Blt_part(UBYTE*, int, int, int, int, UBYTE*);
+void hicolor565_Blt(UBYTE*);
+void hicolor565_Blt_part(UBYTE*, int, int, int, int, UBYTE*);
+
+void palette_update();
+
+static tCls        pCls        = NULL;
+static tBlt		   pBlt	       = NULL;
+static tBlt_part   pBlt_part   = NULL;
+
+static int _geometry_w;
+static int _geometry_h;  
+static int _saved_geometry_h;
+
+HWND hWndMain;
+
+
+void SetScreenMode(int mode)
+{
+	currentScreenMode = mode;
+	if(currentScreenMode > maxMode)
+		currentScreenMode = 0;
+}
+
+int GetScreenMode()
+{
+	return currentScreenMode;
+}
+
+void GraphicsSuspend()
+{
+	if(active)
+	{
+		active = 0;
+		GXSuspend();
+	}
+}
+
+void GraphicsResume()
+{
+	if(!active)
+	{
+		active = 1;
+		GXResume();
+	}
+
+	palette_update();
+}
+
+void GraphicsOff(void)
+{
+	GXCloseDisplay();
+	active = 0;
+}
+
+void SetScreenGeometry(int w, int h) {
+	// Complain (loudly) if w > 320 and h > 240 ...
+	if (w != 320 || h > 240) {
+		MessageBox(NULL, TEXT("Unsupported screen geometry !"), TEXT("Error"), MB_OK);
+		exit(1);
+	}
+
+	_geometry_w = w;
+	_geometry_h = h;
+	_saved_geometry_h = h;
+	RestoreScreenGeometry();
+}
+
+void LimitScreenGeometry() {
+
+	if (_geometry_h > 200) {
+		geom[0].lineLimit = _geometry_w*200;
+		geom[1].lineLimit = _geometry_w*200;
+		geom[1].lineLimit = _geometry_w*200;
+		_geometry_h = 200;
+	}
+}
+
+void RestoreScreenGeometry() {
+	_geometry_h = _saved_geometry_h;
+	geom[0].lineLimit = _geometry_w * _geometry_h;
+	geom[1].lineLimit = _geometry_w * _geometry_h;
+	geom[2].lineLimit = _geometry_w * _geometry_h;
+}
+
+int GraphicsOn(HWND hWndMain_param)
+{
+	hWndMain = hWndMain_param;
+	GXOpenDisplay(hWndMain, GX_FULLSCREEN);
+	
+	gxdp = GXGetDisplayProperties();
+
+	if(gxdp.ffFormat & kfDirect565)
+	{
+		pCls =    hicolor_Cls;
+		pBlt =    hicolor565_Blt;
+		pBlt_part = hicolor565_Blt_part;
+		filter_available = 1;
+		smooth_filter = 1;
+		toolbar_available = 1;
+	}
+	else if(gxdp.ffFormat & kfDirect555)
+	{
+		pCls =    hicolor_Cls;
+		pBlt =    hicolor555_Blt;
+		pBlt_part = hicolor555_Blt_part;
+		filter_available = 1;
+		smooth_filter = 1;
+		toolbar_available = 1;
+	}
+	else if((gxdp.ffFormat & kfDirect) && (gxdp.cBPP <= 8))
+	{
+		pCls =  mono_Cls;
+		pBlt =  mono_Blt;
+		pBlt_part = mono_Blt_part;
+		
+		if(gxdp.ffFormat & kfDirectInverted)
+			invert = (1<<gxdp.cBPP)-1;
+		colorscale = gxdp.cBPP < 8 ? 8-gxdp.cBPP : 0;
+
+		if(gxdp.cBPP >= 4)
+			filter_available = 1;
+
+		toolbar_available = 1;
+	}
+	else if(gxdp.ffFormat & kfPalette)
+	{
+		pCls =    palette_Cls;
+		pBlt =    palette_Blt;
+		pBlt_part = palette_Blt_part;
+		
+		toolbar_available = 1;
+	}
+
+
+	if(!pCls || !pBlt || gxdp.cxWidth < 240 || gxdp.cyHeight < 
+240)
+	{
+	// I don't believe there are devices that end up here
+		GraphicsOff();
+		return 1;
+	}
+	
+	// portrait
+	geom[0].width = gxdp.cxWidth; // 240
+	geom[0].height = gxdp.cyHeight; // 320
+	geom[0].startoffset = 0;
+	geom[0].sourceoffset = 0;
+	geom[0].linestep = gxdp.cbyPitch;
+	geom[0].pixelstep = gxdp.cbxPitch;
+	geom[0].xSkipMask = gxdp.cxWidth < 320 ? 0x00000003 : 0xffffffff;
+	geom[0].xLimit = 320; // skip 1/4
+	geom[0].lineLimit = 320*200;
+	
+	// left handed landscape
+	geom[1].width = gxdp.cyHeight; // 320
+	geom[1].height = gxdp.cxWidth; // 240
+	geom[1].startoffset = gxdp.cbyPitch*(gxdp.cyHeight-1);
+	geom[1].sourceoffset = 0;
+	geom[1].linestep = gxdp.cbxPitch;
+	geom[1].pixelstep = -gxdp.cbyPitch;
+	geom[1].xSkipMask = 0xffffffff;
+	geom[1].xLimit = 320; // no skip
+	geom[1].lineLimit = 320*200;	
+	
+	// right handed landscape
+	geom[2].width = gxdp.cyHeight; // 320
+	geom[2].height = gxdp.cxWidth; // 240
+	geom[2].startoffset = gxdp.cbxPitch*(gxdp.cxWidth-1);
+	geom[2].sourceoffset = 0;
+	geom[2].linestep = -gxdp.cbxPitch;
+	geom[2].pixelstep = gxdp.cbyPitch;
+	geom[2].xSkipMask = 0xffffffff;
+	geom[2].xLimit = 320; // no skip
+	geom[2].lineLimit = 320*200;
+	
+	if(gxdp.cyHeight < 320)
+		maxMode = 0; // portrait only!
+
+	/*
+	for(int i = 0; i < MAX_CLR; i++)
+	{
+		SetPalEntry(i,  (colortable[i] >> 16) & 0xff,
+			(colortable[i] >> 8) & 0xff,
+			(colortable[i]) & 0xff);
+	}
+	*/
+
+	//palette_update();
+
+	active = 1;
+	return 0;
+}
+
+/* Find the best color match in the palette (limited to 'limit' entries) */ 
+   UBYTE best_match(UBYTE r, UBYTE g, UBYTE b, int limit) 
+   { 
+           UBYTE best = 0; 
+           int distance = 768; 
+           int i, d; 
+           for(i=0; i<limit; i++) 
+           { 
+           /* Manhattan distance for now. Not the best but rather fast */ 
+                   d = abs(r-palRed[i])+abs(g-palGreen[i])+abs(b-palBlue[i]); 
+                   if(d < distance) 
+                   { 
+                           distance = d; 
+                           best = i; 
+                   } 
+           } 
+    
+           return (UBYTE)best; 
+   } 
+
+
+void palette_update()
+{
+	if(gxdp.ffFormat & kfPalette)
+	{
+		LOGPALETTE* ple = 
+(LOGPALETTE*)malloc(sizeof(LOGPALETTE)+sizeof(PALETTEENTRY)*255);
+		ple->palVersion = 0x300;
+		ple->palNumEntries = 256;
+		for(int i=0; i<236; i++) // first 10 and last ten belong to the system!
+		{
+			ple->palPalEntry[i+10].peBlue =  palBlue[i];
+			ple->palPalEntry[i+10].peGreen = palGreen[i];
+			ple->palPalEntry[i+10].peRed =   palRed[i];
+			ple->palPalEntry[i+10].peFlags = PC_RESERVED;
+		}
+		HDC hDC = GetDC(hWndMain);
+		GetSystemPaletteEntries(hDC, 0, 10, &(ple->palPalEntry[0]));
+		GetSystemPaletteEntries(hDC, 246, 10, &(ple->palPalEntry[246]));
+		HPALETTE hpal =	CreatePalette(ple);
+		SelectPalette(hDC, hpal, FALSE);
+		RealizePalette(hDC);
+		DeleteObject((HGDIOBJ)hpal);
+		ReleaseDC(hWndMain, hDC);
+		free((void*)ple);
+
+		for(i=0; i<20; i++) 
+          staticTranslate[i] = best_match(palRed[i+236], palGreen[i+236], palBlue[i+236], 236)+10; 
+
+	}
+}
+
+void SetPalEntry(int ent, UBYTE r, UBYTE g, UBYTE b)
+{
+	if (ent >= MAX_CLR)
+		return;
+
+	palRed[ent] = r;
+	palGreen[ent] = g;
+	palBlue[ent] = b;
+
+	if(gxdp.ffFormat & kfDirect565)
+		pal[ent] = COLORCONV565(r,g,b);
+	else if(gxdp.ffFormat & kfDirect555)
+		pal[ent] = COLORCONV555(r,g,b);
+	else if(gxdp.ffFormat & kfDirect)
+		pal[ent] = COLORCONVMONO(r,g,b);
+}
+
+/* *************** CLS IMPLEMENTATIONS ****************** */
+
+void mono_Cls()
+{
+	int x, y;
+	UBYTE* dst;
+	UBYTE *scraddr;
+	int linestep, pixelstep;
+	UBYTE fillcolor;
+
+	fillcolor = (gxdp.ffFormat & kfDirectInverted) ? 0xff : 0x00;
+
+	pixelstep = geom[0].pixelstep;
+	if(pixelstep == 0)
+		return;
+	linestep = (pixelstep > 0) ? -1 : 1;
+
+	scraddr = (UBYTE*)GXBeginDraw();
+	if(scraddr)
+	{
+		for(y=0; y<geom[0].height*gxdp.cBPP/8; y++)
+		{
+			dst = scraddr+geom[0].startoffset;
+			for(x=0; x<geom[0].width; x++)
+			{
+				*dst = fillcolor;
+				dst += pixelstep;
+			}
+			scraddr += linestep;
+		}
+		GXEndDraw();
+	}
+}
+
+void palette_Cls()
+{
+	int x, y;
+	UBYTE* dst;
+	UBYTE *scraddr;
+	scraddr = (UBYTE*)GXBeginDraw();
+	if(scraddr)
+	{
+		for(y=0; y<geom[useMode].height; y++)
+		{
+			dst = scraddr+geom[useMode].startoffset;
+			for(x=0; x<geom[useMode].width; x++)
+			{
+				*dst = 0;
+				dst += geom[useMode].pixelstep;
+			}
+			scraddr += geom[useMode].linestep;
+		}
+		GXEndDraw();
+	}
+}
+
+void hicolor_Cls()
+{
+	int x, y;
+	UBYTE* dst;
+	UBYTE *scraddr;
+	scraddr = (UBYTE*)GXBeginDraw();
+	if(scraddr)
+	{
+		for(y=0; y<geom[useMode].height; y++)
+		{
+			dst = scraddr+geom[useMode].startoffset;
+			for(x=0; x<geom[useMode].width; x++)
+			{
+				*(unsigned short*)dst = 0;
+				dst += geom[useMode].pixelstep;
+			}
+			scraddr += geom[useMode].linestep;
+		}
+		GXEndDraw();
+	}
+}
+
+
+void Cls()
+{
+	pCls();
+}
+int counter = 0;
+
+/*
+void drawToolbarItem(UBYTE* palette, UBYTE* item, int dest_x, int dest_y, int width_item, int height_item) {
+	
+	int x,y,z;
+	UBYTE* dst;
+	UBYTE *scraddr;
+
+	scraddr = (UBYTE*)GXBeginDraw();
+	if(scraddr)
+	{
+		scraddr += dest_y * geom[useMode].linestep;
+
+		z = 0;
+
+		for (y=dest_y; y<dest_y + height_item; y++) {
+			dst = scraddr + geom[useMode].startoffset + dest_x * geom[useMode].pixelstep;
+			for (x=dest_x; x<dest_x + width_item; x++) {
+				if(gxdp.ffFormat & kfDirect565)
+		*(unsigned short*)dst = 
+			COLORCONV565(palette[item[z] * 3], palette[item[z] * 3 + 1], palette[item[z] * 3 + 2]);
+	       else if(gxdp.ffFormat & kfDirect555)
+		*(unsigned short*)dst = 
+			COLORCONV555(palette[item[z] * 3], palette[item[z] * 3 + 1], palette[item[z] * 3 + 2]);
+		   else if((gxdp.ffFormat & kfDirect) && (gxdp.cBPP <= 8))
+		*(unsigned short*)dst = 
+			COLORCONVMONO(palette[item[z] * 3], palette[item[z] * 3 + 1], palette[item[z] * 3 + 2]);
+
+
+				dst += geom[useMode].pixelstep;
+				//z += 3;
+				z += 1;
+			}
+			scraddr += geom[useMode].linestep;
+		}
+	}
+	GXEndDraw();
+}
+*/
+
+
+void drawSoundItem(int x, int y) {
+	if (sound_activated)
+		pBlt_part(item_soundOn, x, y, 32, 32, item_soundOn_colors);
+	else
+		pBlt_part(item_soundOff, x, y, 32, 32, item_soundOff_colors);
+}
+
+void drawWait() {
+	pBlt_part(item_toolbar, 0, 0, 320, 40, item_toolbar_colors);
+	pBlt_part(item_loading, 28, 10, 100, 25, item_loading_colors);
+}
+
+void drawAllToolbar() {
+	int x,y;
+
+	if (currentScreenMode) {
+
+		if (draw_keyboard) {
+			pBlt_part(item_keyboard, 0, 200, 320, 40, item_keyboard_colors);
+		}
+		else {
+			pBlt_part(item_toolbar, 0, 200, 320, 40, item_toolbar_colors);
+			x = 10;
+			y = 204;
+			pBlt_part(item_disk, x, y, 32, 32, item_disk_colors);
+			x += 40;
+			pBlt_part(item_skip, x, y, 32, 32, item_skip_colors);
+			x += 40;
+			drawSoundItem(x, y);
+			x += 40;
+			pBlt_part(item_monkeyPortrait, x, y, 32, 32, 
+					item_monkeyPortrait_colors);
+		}
+	}
+	else {
+			if (draw_keyboard) {
+				pBlt_part(item_keyboardPortrait, 0, 240, 320, 80,
+							item_keyboardPortrait_colors);
+			}
+			else {
+			pBlt_part(item_toolbarPortrait, 0, 240, 320, 80, 
+						item_toolbarPortrait_colors);
+			/*drawToolbarItem(item_toolbarPortrait_colors, item_toolbarPortrait,
+							0, 240, 240, 80);*/
+			x = 10;
+			y = 240;
+			pBlt_part(item_disk, x, y, 32, 32, item_disk_colors);
+			x += 40;
+			pBlt_part(item_skip, x, y, 32, 32, item_skip_colors);
+			x += 40;
+			drawSoundItem(x, y);
+			x += 40;
+			pBlt_part(item_monkeyLandscape, x, y, 32, 32,
+						item_monkeyLandscape_colors);			
+		}
+	}
+
+	toolbar_drawn = true;
+}
+
+void redrawSoundItem() {
+	drawSoundItem(10 + 40 + 40, (currentScreenMode ? 204 : 240));
+}
+
+bool isInBox(int x, int y, int x1, int y1, int x2, int y2) {
+	return ((x >= x1 && y >= y1) && (x <= x2 && y <= y2));
+}
+
+ToolbarSelected getToolbarSelection (int x, int y) {
+	int test_x, test_y;
+
+	/*
+	if (!currentScreenMode)
+		return ToolbarNone;
+	*/
+
+	if (!(x >= 10 && y >= 204))
+		return ToolbarNone;
+	
+	test_x = 10;
+	test_y = (currentScreenMode ? 204 : 240);
+	if (isInBox(x, y, test_x, test_y, test_x + 32, test_y + 32))
+		return ToolbarSaveLoad;
+	test_x += 40;
+	if (isInBox(x, y, test_x, test_y, test_x + 32, test_y + 32))
+		return ToolbarSkip;
+	test_x += 40;
+	if (isInBox(x, y, test_x, test_y, test_x + 32, test_y + 32))
+		return ToolbarSound;
+	test_x += 40;
+	if (isInBox(x, y, test_x, test_y, test_x + 32, test_y + 32))
+		return ToolbarMode;
+	return ToolbarNone;
+}
+	
+/* ************************** BLT IMPLEMENTATION **************************** */
+
+void Blt(UBYTE * scr_ptr) 
+{
+	pBlt(scr_ptr);
+
+	//if (toolbar_available && currentScreenMode && !toolbar_drawn)
+	if (toolbar_available && !toolbar_drawn && !hide_toolbar)
+		drawAllToolbar();
+
+}
+
+
+#define ADVANCE_PARTIAL(address, step) \
+	bitshift += gxdp.cBPP;             \
+	if(bitshift >= 8)                  \
+	{                                  \
+		bitshift = 0;                  \
+		bitmask = (1<<gxdp.cBPP)-1;    \
+		address += step;               \
+	}                                  \
+	else                               \
+		bitmask <<= gxdp.cBPP;
+
+#define ADVANCE_REV_PARTIAL(address, step)        \
+	bitshift -= gxdp.cBPP;                        \
+	if(bitshift < 0)                              \
+	{                                             \
+		bitshift = 8-gxdp.cBPP;                   \
+		bitmask = ((1<<gxdp.cBPP)-1)<<bitshift;   \
+		address += step;                          \
+	}                                             \
+	else                                          \
+		bitmask >>= gxdp.cBPP;
+
+
+void mono_Blt(UBYTE *src_ptr) {
+	mono_Blt_part(src_ptr, 0, 0, _geometry_w, _geometry_h, NULL);
+}
+
+
+void mono_Blt_part(UBYTE * scr_ptr, int x, int y, int width, int height,
+				    UBYTE * own_palette)
+{
+// Mono blit routines contain good deal of voodoo
+	static UBYTE *src;
+	static UBYTE *dst;
+	static UBYTE *scraddr;
+	static UBYTE *scr_ptr_limit;
+	static UBYTE *src_limit;
+	static long pixelstep;
+	static long linestep;
+	static long skipmask;
+
+// Special code is used to deal with packed pixels in monochrome mode
+	static UBYTE bitmask;
+	static int   bitshift;
+
+	if(!active)
+	{
+		Sleep(100);
+		return;
+	}
+
+	/* Update screen mode, also thread protection by doing this */
+	if(useMode != currentScreenMode)
+	{
+		useMode = currentScreenMode;
+		pCls();
+	}
+
+	pixelstep = geom[useMode].pixelstep;
+	linestep = geom[useMode].linestep;
+	skipmask = geom[useMode].xSkipMask;
+
+	scraddr = (UBYTE*)GXBeginDraw();
+
+	if(pixelstep)
+	{
+	// this will work on mono iPAQ and @migo, don't know about any others
+		linestep = (pixelstep > 0) ? -1 : 1;
+
+		bitshift = 0;
+		bitmask = (1<<gxdp.cBPP)-1;
+
+		if(scraddr)
+		{
+			scraddr += geom[useMode].startoffset;
+			scr_ptr += geom[useMode].sourceoffset;
+			//scr_ptr_limit = scr_ptr + geom[useMode].lineLimit;
+			//src_limit = scr_ptr + geom[useMode].xLimit;
+
+			/* Update offsets to the current line */
+			scraddr += y * linestep;
+			scr_ptr_limit = scr_ptr + width * height;
+			src_limit = scr_ptr + width;
+
+
+			/* Internal pixel loops */
+			if(skipmask == 3 && (smooth_filter) && gxdp.cBPP >= 4)
+			{
+				while(scr_ptr < scr_ptr_limit)
+				{
+					int i;
+
+					src = scr_ptr;
+					dst = scraddr;
+
+					/* skip non updated pixels for this line */
+					for (i=0; i < x; i++)
+						dst += pixelstep;
+
+					while(src < src_limit)
+					{
+						UBYTE r, g, b;
+
+						if (!own_palette) {
+							r = (3*palRed[*(src+0)] + palRed[*(src+1)])>>2;
+							g = (3*palGreen[*(src+0)] + palGreen[*(src+1)])>>2;
+							b = (3*palBlue[*(src+0)] + palBlue[*(src+1)])>>2;
+						} else {
+							r = (3 * own_palette[3 * *(src + 0)] + 
+									own_palette[3 * *(src + 1)]) >> 2;
+							g = (3 * own_palette[3 * *(src + 0) + 1] +
+									own_palette[3 * *(src + 1) + 1]) >> 2;
+							b = (3 * own_palette[3 * *(src + 0) + 2] +
+									own_palette[3 * *(src + 1) + 2]) >> 2;
+						}
+						
+						
+						*dst = (*dst & ~bitmask) | (COLORCONVMONO(r,g,b)<<bitshift);
+
+						dst += pixelstep;
+
+						if (!own_palette) {
+							r = (palRed[*(src+1)] + palRed[*(src+2)])>>1;
+							g = (palGreen[*(src+1)] + palGreen[*(src+2)])>>1;
+							b = (palBlue[*(src+1)] + palBlue[*(src+2)])>>1;
+						}
+						else {
+							r = (own_palette[3 * *(src + 1)] + 
+									own_palette[3 * *(src + 2)]) >> 2;
+							g = (own_palette[3 * *(src + 1) + 1] +
+									own_palette[3 * *(src + 2) + 1]) >> 2;
+							b = (own_palette[3 * *(src + 1) + 2] +
+									own_palette[3 * *(src + 2) + 2]) >> 2;
+						}
+
+						*dst = (*dst & ~bitmask) | (COLORCONVMONO(r,g,b)<<bitshift);
+
+						dst += pixelstep;
+
+						if (!own_palette) {
+							r = (palRed[*(src+2)] + 3*palRed[*(src+3)])>>2;
+							g = (palGreen[*(src+2)] + 3*palGreen[*(src+3)])>>2;
+							b = (palBlue[*(src+2)] + 3*palBlue[*(src+3)])>>2;
+						}
+						else {
+							r = (own_palette[3 * *(src + 2)] + 
+									3 * own_palette[3 * *(src + 3)]) >> 2;
+							g = (own_palette[3 * *(src + 2) + 1] +
+									3 * own_palette[3 * *(src + 3) + 1]) >> 2;
+							b = (own_palette[3 * *(src + 2) + 2] +
+									3 * own_palette[3 * *(src + 3) + 2]) >> 2;
+
+						}
+
+						*dst = (*dst & ~bitmask) | (COLORCONVMONO(r,g,b)<<bitshift);
+
+						dst += pixelstep;
+
+						src += 4;
+					}
+
+					ADVANCE_PARTIAL(scraddr, linestep);
+
+					scr_ptr += width;
+					src_limit += width;
+				}
+			}
+			else if(skipmask != 0xffffffff)
+			{
+				while(scr_ptr < scr_ptr_limit)
+				{
+					int i;
+
+					src = scr_ptr;
+					dst = scraddr;
+
+					/* skip non updated pixels for this line */
+					for (i=0; i < x; i++)
+						dst += pixelstep;
+
+					while(src < src_limit)
+					{
+						if((long)src & skipmask)
+						{
+							if (!own_palette)
+								*dst = ((*dst)&~bitmask)|(pal[*src]<<bitshift);
+							else
+								*dst = ((*dst)&~bitmask)|(COLORCONVMONO(
+									own_palette[3 * *src], 
+									own_palette[(3 * *src) + 1],
+									own_palette[(3 * *src) + 2]) << bitshift);
+							dst += pixelstep;
+						}
+						src ++;
+					}
+
+					ADVANCE_PARTIAL(scraddr, linestep);
+
+					scr_ptr += width;
+					src_limit += width;
+				}
+			}
+			else
+			{
+				while(scr_ptr < scr_ptr_limit)
+				{
+					int i;
+
+					src = scr_ptr;
+					dst = scraddr;
+
+					/* skip non updated pixels for this line */
+					for (i=0; i < x; i++)
+						dst += pixelstep;
+
+					while(src < src_limit)
+					{
+							if (!own_palette)
+								*dst = ((*dst)&~bitmask)|(pal[*src]<<bitshift);
+							else
+								*dst = ((*dst)&~bitmask)|(COLORCONVMONO(
+									own_palette[3 * *src], 
+									own_palette[(3 * *src) + 1],
+									own_palette[(3 * *src) + 2]) << bitshift);
+						dst += pixelstep;
+						src ++;
+					}
+
+					ADVANCE_PARTIAL(scraddr, linestep);
+
+					scr_ptr += width;
+					src_limit += width;
+				}
+			}
+		}
+	}
+	else
+	{
+	// Filtering is not implemented in this mode. Not needed by current devices anyway
+		pixelstep = (linestep > 0) ? 1 : -1;
+
+		if(scraddr)
+		{
+
+			scraddr += geom[useMode].startoffset;
+			scr_ptr += geom[useMode].sourceoffset;
+			//scr_ptr_limit = scr_ptr + geom[useMode].lineLimit;
+			//src_limit = scr_ptr + geom[useMode].xLimit;
+
+			/* Update offsets to the current line */
+			scraddr += y * linestep;
+			scr_ptr_limit = scr_ptr + width * height;
+			src_limit = scr_ptr + width;
+
+			if(skipmask != 0xffffffff)
+			{
+				if(pixelstep > 0)
+				{
+					bitshift = 8-gxdp.cBPP;
+					bitmask = ((1<<gxdp.cBPP)-1)<<bitshift;
+
+					while(scr_ptr < scr_ptr_limit)
+					{
+						int i;
+
+						src = scr_ptr;
+						dst = scraddr;
+						dst -= (linestep-pixelstep);
+
+						/* skip non updated pixels for this line */
+						for (i=0; i < x; i++)
+							ADVANCE_REV_PARTIAL(dst, pixelstep);
+
+						while(src < src_limit)
+						{
+							if((long)src & skipmask)
+							{
+								if (!own_palette)
+									*dst = ((*dst)&~bitmask)|(pal[*src]<<bitshift);
+								else
+									*dst = ((*dst)&~bitmask)|(COLORCONVMONO(
+										own_palette[3 * *src], 
+										own_palette[(3 * *src) + 1],
+										own_palette[(3 * *src) + 2]) << bitshift);
+								ADVANCE_REV_PARTIAL(dst, pixelstep);
+							}
+							src ++;
+						}
+
+						scraddr += linestep;
+
+						scr_ptr += width;
+						src_limit += width;
+					}
+				}
+				else
+				{
+					bitshift = 0;
+					bitmask = (1<<gxdp.cBPP)-1;
+
+					while(scr_ptr < scr_ptr_limit)
+					{
+						int i;
+
+						src = scr_ptr;
+						dst = scraddr;
+
+						/* skip non updated pixels for this line */
+						for (i=0; i < x; i++)
+							ADVANCE_PARTIAL(dst, pixelstep);
+
+						while(src < src_limit)
+						{
+							if((long)src & skipmask)
+							{
+								if (!own_palette)
+									*dst = ((*dst)&~bitmask)|(pal[*src]<<bitshift);
+								else
+									*dst = ((*dst)&~bitmask)|(COLORCONVMONO(
+										own_palette[3 * *src], 
+										own_palette[(3 * *src) + 1],
+										own_palette[(3 * *src) + 2]) << bitshift);
+								ADVANCE_PARTIAL(dst, pixelstep);
+							}
+							src ++;
+						}
+
+						scraddr += linestep;
+
+						scr_ptr += width;
+						src_limit += width;
+					}
+				}
+			}
+			else
+			{
+				if(pixelstep > 0)
+				{
+					bitshift = 8-gxdp.cBPP;
+					bitmask = ((1<<gxdp.cBPP)-1)<<bitshift;
+
+					while(scr_ptr < scr_ptr_limit)
+					{
+						int i;
+
+						src = scr_ptr;
+						dst = scraddr;
+						dst -= (linestep-pixelstep);
+
+						/* skip non updated pixels for this line */
+						for (i=0; i < x; i++)
+							ADVANCE_REV_PARTIAL(dst, pixelstep);
+
+						while(src < src_limit)
+						{
+							if (!own_palette)
+								*dst = ((*dst)&~bitmask)|(pal[*src]<<bitshift);
+							else
+								*dst = ((*dst)&~bitmask)|(COLORCONVMONO(
+										own_palette[3 * *src], 
+										own_palette[(3 * *src) + 1],
+										own_palette[(3 * *src) + 2]) << bitshift);
+							ADVANCE_REV_PARTIAL(dst, pixelstep);
+							src ++;
+						}
+
+						scraddr += linestep;
+
+						scr_ptr += width;
+						src_limit += width;
+					}
+				}
+				else
+				{
+					bitshift = 0;
+					bitmask = (1<<gxdp.cBPP)-1;
+
+					while(scr_ptr < scr_ptr_limit)
+					{
+						int i;
+
+						src = scr_ptr;
+						dst = scraddr;
+
+						/* skip non updated pixels for this line */
+						for (i=0; i < x; i++)
+							ADVANCE_PARTIAL(dst, pixelstep);
+
+
+						while(src < src_limit)
+						{
+							if (!own_palette)
+								*dst = ((*dst)&~bitmask)|(pal[*src]<<bitshift);
+							else
+								*dst = ((*dst)&~bitmask)|(COLORCONVMONO(
+										own_palette[3 * *src], 
+										own_palette[(3 * *src) + 1],
+										own_palette[(3 * *src) + 2]) << bitshift);
+							ADVANCE_PARTIAL(dst, pixelstep);
+							src ++;
+						}
+
+						scraddr += linestep;
+
+						scr_ptr += width;
+						src_limit += width;
+					}
+				}
+			}
+		}
+	}
+	GXEndDraw();
+}
+
+void palette_Blt(UBYTE *src_ptr) {
+	palette_Blt_part(src_ptr, 0, 0, _geometry_w, _geometry_h, NULL);
+}
+
+void palette_Blt_part(UBYTE * scr_ptr,int x, int y, int width, int height,
+				    UBYTE * own_palette)
+{
+	static UBYTE *src;
+	static UBYTE *dst;
+	static UBYTE *scraddr;
+	static UBYTE *scr_ptr_limit;
+	static UBYTE *src_limit;
+	static long pixelstep;
+	static long linestep;
+	static long skipmask;
+
+// Special code is used to deal with packed pixels in monochrome mode
+	static UBYTE bitmask;
+	static int   bitshift;
+
+	if(!active)
+	{
+		Sleep(100);
+		return;
+	}
+
+	/* Update screen mode, also thread protection by doing this */
+	if(useMode != currentScreenMode)
+	{
+		useMode = currentScreenMode;
+		pCls();
+	}
+
+	pixelstep = geom[useMode].pixelstep;
+	linestep = geom[useMode].linestep;
+	skipmask = geom[useMode].xSkipMask;
+
+	scraddr = (UBYTE*)GXBeginDraw();
+	if(scraddr)
+	{
+
+		scraddr += geom[useMode].startoffset;
+		scr_ptr += geom[useMode].sourceoffset;
+		//scr_ptr_limit = scr_ptr + geom[useMode].lineLimit;
+		//src_limit = scr_ptr + geom[useMode].xLimit;
+
+		/* Update offsets to the current line */
+        scraddr += y * linestep;
+        scr_ptr_limit = scr_ptr + width * height;
+        src_limit = scr_ptr + width;
+
+		/* Internal pixel loops */
+		if(skipmask != 0xffffffff)
+		{
+			while(scr_ptr < scr_ptr_limit)
+			{
+				int i;
+
+				src = scr_ptr;
+				dst = scraddr;
+
+				/* skip non updated pixels for this line */
+				for (i=0; i < x; i++)
+					dst += pixelstep;
+
+				while(src < src_limit)
+				{
+					if((long)src & skipmask)
+					{
+						if (!own_palette) {
+							if (*src < 236)
+								*dst = *src + 10;
+							else
+								*dst = staticTranslate[*src-236];
+						} else {
+							unsigned char color_match[500];
+							// Turtle warning !!!
+							memset(color_match, 255, sizeof(color_match));
+							if (color_match[*src] == 255)
+								color_match[*src] = 
+									best_match(own_palette[(3 * *src)],
+										own_palette[(3 * *src) + 1], 
+										own_palette[(3 * *src) + 2], 236) + 10;
+							*dst = color_match[*src];
+						}
+						dst += pixelstep;
+					}
+					src ++;
+				}
+				scraddr += linestep;
+				scr_ptr += width;
+				src_limit += width;
+			}
+		}
+		else
+		{
+			while(scr_ptr < scr_ptr_limit)
+			{
+				int i;
+
+				src = scr_ptr;
+				dst = scraddr;
+
+				/* skip non updated pixels for this line */
+				for (i=0; i < x; i++)
+					dst += pixelstep;
+
+
+				while(src < src_limit)
+				{
+					if (!own_palette) {
+						if (*src < 236)
+							*dst = *src + 10; 
+						else
+							*dst = staticTranslate[*src-236];
+					}
+					else {
+							unsigned char color_match[500];
+							// Turtle warning !!!
+							memset(color_match, 255, sizeof(color_match));
+							if (color_match[*src] == 255)
+								color_match[*src] = 
+									best_match(own_palette[(3 * *src)],
+										own_palette[(3 * *src) + 1], 
+										own_palette[(3 * *src) + 2], 236) + 10;
+							*dst = color_match[*src];
+					}
+					dst += pixelstep;
+					src ++;
+				}
+				scraddr += linestep;
+				scr_ptr += width;
+				src_limit += width;
+			}
+		}
+
+		GXEndDraw();
+	}
+}
+
+void hicolor555_Blt(UBYTE *src_ptr) {
+	hicolor555_Blt_part(src_ptr, 0, 0, _geometry_w, _geometry_h, NULL);
+}
+
+
+void hicolor555_Blt_part(UBYTE * scr_ptr,int x, int y, int width, int height,
+				    UBYTE * own_palette)
+{
+	static UBYTE *src;
+	static UBYTE *dst;
+	static UBYTE *scraddr;
+	static UBYTE *scr_ptr_limit;
+	static UBYTE *src_limit;
+	static long pixelstep;
+	static long linestep;
+	static long skipmask;
+
+	if(!active)
+	{
+		Sleep(100);
+		return;
+	}
+
+	/* Update screen mode, also thread protection by doing this */
+	if(useMode != currentScreenMode)
+	{
+		useMode = currentScreenMode;
+		pCls();
+	}
+
+	pixelstep = geom[useMode].pixelstep;
+	linestep = geom[useMode].linestep;
+	skipmask = geom[useMode].xSkipMask;
+
+	scraddr = (UBYTE*)GXBeginDraw();
+	if(scraddr)
+	{
+
+		scraddr += geom[useMode].startoffset;
+		scr_ptr += geom[useMode].sourceoffset;
+		//scr_ptr_limit = scr_ptr + geom[useMode].lineLimit;
+		//src_limit = scr_ptr + geom[useMode].xLimit;
+
+		/* Update offsets to the current line */
+        scraddr += y * linestep;
+        scr_ptr_limit = scr_ptr + width * height;
+        src_limit = scr_ptr + width;
+
+		/* Internal pixel loops */
+		if(skipmask == 3 && smooth_filter)
+		{
+			while(scr_ptr < scr_ptr_limit)
+			{
+				int i;
+
+				src = scr_ptr;
+				dst = scraddr;
+
+				/* skip non updated pixels for this line */
+				for (i=0; i < x; i++)
+					dst += pixelstep;
+
+				while(src < src_limit)
+				{
+					UBYTE r, g, b;
+					if (!own_palette) {
+						r = (3*palRed[*(src+0)] + palRed[*(src+1)])>>2;
+						g = (3*palGreen[*(src+0)] + palGreen[*(src+1)])>>2;
+						b = (3*palBlue[*(src+0)] + palBlue[*(src+1)])>>2;
+					} else {
+						r = (3 * own_palette[3 * *(src + 0)] + 
+							     own_palette[3 * *(src + 1)]) >> 2;
+						g = (3 * own_palette[3 * *(src + 0) + 1] +
+								 own_palette[3 * *(src + 1) + 1]) >> 2;
+						b = (3 * own_palette[3 * *(src + 0) + 2] +
+							     own_palette[3 * *(src + 1) + 2]) >> 2;
+					}
+
+					*(unsigned short*)dst = COLORCONV555(r,g,b);
+
+					dst += pixelstep;
+
+					if (!own_palette) {
+						r = (palRed[*(src+1)] + palRed[*(src+2)])>>1;
+						g = (palGreen[*(src+1)] + palGreen[*(src+2)])>>1;
+						b = (palBlue[*(src+1)] + palBlue[*(src+2)])>>1;
+					}
+					else {
+						r = (own_palette[3 * *(src + 1)] + 
+							     own_palette[3 * *(src + 2)]) >> 2;
+						g = (own_palette[3 * *(src + 1) + 1] +
+								 own_palette[3 * *(src + 2) + 1]) >> 2;
+						b = (own_palette[3 * *(src + 1) + 2] +
+							     own_palette[3 * *(src + 2) + 2]) >> 2;
+					}
+
+					*(unsigned short*)dst = COLORCONV555(r,g,b);
+
+					dst += pixelstep;
+
+					if (!own_palette) {
+						r = (palRed[*(src+2)] + 3*palRed[*(src+3)])>>2;
+						g = (palGreen[*(src+2)] + 3*palGreen[*(src+3)])>>2;
+						b = (palBlue[*(src+2)] + 3*palBlue[*(src+3)])>>2;
+					}
+					else {
+						r = (own_palette[3 * *(src + 2)] + 
+							     3 * own_palette[3 * *(src + 3)]) >> 2;
+						g = (own_palette[3 * *(src + 2) + 1] +
+								 3 * own_palette[3 * *(src + 3) + 1]) >> 2;
+						b = (own_palette[3 * *(src + 2) + 2] +
+							     3 * own_palette[3 * *(src + 3) + 2]) >> 2;
+
+					}
+
+					*(unsigned short*)dst = COLORCONV555(r,g,b);
+
+					dst += pixelstep;
+
+					src += 4;
+				}
+				scraddr += linestep;
+				scr_ptr += width;
+				src_limit += width;
+			}
+		}
+		else if(skipmask != 0xffffffff)
+		{
+			while(scr_ptr < scr_ptr_limit)
+			{
+				int i;
+
+				src = scr_ptr;
+				dst = scraddr;
+
+				/* skip non updated pixels for this line */
+				for (i=0; i < x; i++)
+					dst += pixelstep;
+
+
+				while(src < src_limit)
+				{
+					if((long)src & skipmask)
+					{
+						if (!own_palette)
+							*(unsigned short*)dst = pal[*src];
+						else
+							*(unsigned short*)dst = 
+								COLORCONV555(own_palette[3 * *src],
+									own_palette[(3 * *src) + 1], 
+									own_palette[(3 * *src) + 2]);
+						dst += pixelstep;
+					}
+					src ++;
+				}
+				scraddr += linestep;
+				scr_ptr += width;
+				src_limit += width;
+			}
+		}
+		else
+		{
+			while(scr_ptr < scr_ptr_limit)
+			{
+				int i;
+
+				src = scr_ptr;
+				dst = scraddr;
+
+				/* skip non updated pixels for this line */
+				for (i=0; i < x; i++)
+					dst += pixelstep;
+
+
+				while(src < src_limit)
+				{
+					if (!own_palette)
+							*(unsigned short*)dst = pal[*src];
+						else
+							*(unsigned short*)dst = 
+								COLORCONV565(own_palette[3 * *src],
+									own_palette[(3 * *src) + 1], 
+									own_palette[(3 * *src) + 2]);
+						dst += pixelstep;
+						src ++;
+				}
+
+				scraddr += linestep;
+				scr_ptr += width;
+				src_limit += width;
+			}
+		}
+
+		GXEndDraw();
+	}
+}
+
+void hicolor565_Blt(UBYTE *src_ptr) {
+	hicolor565_Blt_part(src_ptr, 0, 0, _geometry_w, _geometry_h, NULL);
+}
+
+void hicolor565_Blt_part(UBYTE * scr_ptr, int x, int y, int width, int height,
+						 UBYTE * own_palette)
+{
+	static UBYTE *src;
+	static UBYTE *dst;
+	static UBYTE *scraddr;
+	static UBYTE *scr_ptr_limit;
+	static UBYTE *src_limit;
+	static long pixelstep;
+	static long linestep;
+	static long skipmask;
+
+	if(!active)
+	{
+		Sleep(100);
+		return;
+	}
+
+	/* Update screen mode, also thread protection by doing this */
+	if(useMode != currentScreenMode)
+	{
+		useMode = currentScreenMode;
+		pCls();
+	}
+
+	pixelstep = geom[useMode].pixelstep;
+	linestep = geom[useMode].linestep;
+	skipmask = geom[useMode].xSkipMask;
+
+	scraddr = (UBYTE*)GXBeginDraw();
+	if(scraddr)
+	{
+
+		scraddr += geom[useMode].startoffset;
+		scr_ptr += geom[useMode].sourceoffset;
+		//scr_ptr_limit = scr_ptr + geom[useMode].lineLimit;
+		//src_limit = scr_ptr + geom[useMode].xLimit;
+
+		/* Update offsets to the current line */
+		scraddr += y * linestep;
+		scr_ptr_limit = scr_ptr + width * height;
+		src_limit = scr_ptr + width;
+
+		/* Internal pixel loops */
+		if(skipmask == 3 && smooth_filter)
+		{
+			while(scr_ptr < scr_ptr_limit)
+			{
+				int i;
+
+				src = scr_ptr;
+				dst = scraddr;
+
+				/* skip non updated pixels for this line */
+				for (i=0; i < x; i++)
+					dst += pixelstep;
+				
+				while(src < src_limit)
+				{
+					UBYTE r, g, b;
+					if (!own_palette) {
+						r = (3*palRed[*(src+0)] + palRed[*(src+1)])>>2;
+						g = (3*palGreen[*(src+0)] + palGreen[*(src+1)])>>2;
+						b = (3*palBlue[*(src+0)] + palBlue[*(src+1)])>>2;
+					} else {
+						r = (3 * own_palette[3 * *(src + 0)] + 
+							     own_palette[3 * *(src + 1)]) >> 2;
+						g = (3 * own_palette[3 * *(src + 0) + 1] +
+								 own_palette[3 * *(src + 1) + 1]) >> 2;
+						b = (3 * own_palette[3 * *(src + 0) + 2] +
+							     own_palette[3 * *(src + 1) + 2]) >> 2;
+					}
+
+					*(unsigned short*)dst = COLORCONV565(r,g,b);
+
+					dst += pixelstep;
+
+					if (!own_palette) {
+						r = (palRed[*(src+1)] + palRed[*(src+2)])>>1;
+						g = (palGreen[*(src+1)] + palGreen[*(src+2)])>>1;
+						b = (palBlue[*(src+1)] + palBlue[*(src+2)])>>1;
+					}
+					else {
+						r = (own_palette[3 * *(src + 1)] + 
+							     own_palette[3 * *(src + 2)]) >> 1;
+						g = (own_palette[3 * *(src + 1) + 1] +
+								 own_palette[3 * *(src + 2) + 1]) >> 1;
+						b = (own_palette[3 * *(src + 1) + 2] +
+							     own_palette[3 * *(src + 2) + 2]) >> 1;
+					}
+
+					*(unsigned short*)dst = COLORCONV565(r,g,b);
+
+					dst += pixelstep;
+
+					if (!own_palette) {
+						r = (palRed[*(src+2)] + 3*palRed[*(src+3)])>>2;
+						g = (palGreen[*(src+2)] + 3*palGreen[*(src+3)])>>2;
+						b = (palBlue[*(src+2)] + 3*palBlue[*(src+3)])>>2;
+					}
+					else {
+						r = (own_palette[3 * *(src + 2)] + 
+							     3 * own_palette[3 * *(src + 3)]) >> 2;
+						g = (own_palette[3 * *(src + 2) + 1] +
+								 3 * own_palette[3 * *(src + 3) + 1]) >> 2;
+						b = (own_palette[3 * *(src + 2) + 2] +
+							     3 * own_palette[3 * *(src + 3) + 2]) >> 2;
+
+					}
+
+					*(unsigned short*)dst = COLORCONV565(r,g,b);
+
+					dst += pixelstep;
+
+					src += 4;
+				}
+
+				scraddr += linestep;
+				scr_ptr += width;
+				src_limit += width;
+			}
+		}
+		else if(skipmask != 0xffffffff)
+		{
+			while(scr_ptr < scr_ptr_limit)
+			{
+				int i;				
+
+				src = scr_ptr;
+				dst = scraddr;
+
+				/* skip non updated pixels for this line */
+				for (i=0; i < x; i++)
+					dst += pixelstep;
+
+				while(src < src_limit)
+				{
+					if((long)src & skipmask)
+					{
+						if (!own_palette)
+							*(unsigned short*)dst = pal[*src];
+						else
+							*(unsigned short*)dst = 
+								COLORCONV565(own_palette[3 * *src],
+									own_palette[(3 * *src) + 1], 
+									own_palette[(3 * *src) + 2]);
+						dst += pixelstep;
+					}
+					src ++;
+				}			
+
+				scraddr += linestep;
+				scr_ptr += width;
+				src_limit += width;
+		}
+		}
+		else
+		{
+			while(scr_ptr < scr_ptr_limit)
+			{
+				int i;
+
+				src = scr_ptr;
+				dst = scraddr;
+
+				/* skip non updated pixels for this line */
+				for (i=0; i < x; i++)
+					dst += pixelstep;
+
+				while(src < src_limit)
+				{
+					if (!own_palette)
+						*(unsigned short*)dst = pal[*src];
+					else
+						*(unsigned short*)dst = 
+							COLORCONV565(own_palette[3 * *src],
+								own_palette[(3 * *src) + 1], 
+								own_palette[(3 * *src) + 2]);
+					dst += pixelstep;
+					src ++;
+				}
+
+				scraddr += linestep;
+				scr_ptr += width;
+				src_limit += width;
+			}
+		}
+
+		GXEndDraw();
+	}
+}
+
+
+void Translate(int* px, int* py)
+{
+	int x, y;
+	
+	switch(currentScreenMode)
+	{
+	case 0: /* portrait */
+		*px = *px*4/3;
+		break;
+	case 1: /* landscape left */
+		x = 320 - *py;
+		y = *px;
+		*px = x;
+		*py = y;
+		break;
+	case 2: /* landscape right */
+		x = *py;
+		y = 240 - *px;
+		*px = x;
+		*py = y;
+		break;
+	}
+}
+
+#endif
diff --git a/backends/wince/screen.h b/backends/wince/screen.h
new file mode 100644
index 0000000000..c7eb2b3af5
--- /dev/null
+++ b/backends/wince/screen.h
@@ -0,0 +1,58 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+/* Original code by Vasyl Tsvirkunov */
+
+#ifndef SCREEN_H
+#define SCREEN_H
+
+#ifndef UBYTE
+#define UBYTE unsigned char
+#endif
+
+void SetScreenGeometry(int w, int h);
+void LimitScreenGeometry();
+void RestoreScreenGeometry();
+int GraphicsOn(HWND hWndMain);
+void GraphicsOff();
+void GraphicsSuspend();
+void GraphicsResume();
+
+void SetPalEntry(int ent, UBYTE r, UBYTE g, UBYTE b);
+void Blt(UBYTE * scr_ptr);
+
+/* meaning: 0 - portrait, 1 - left hand landscape, 2 - right hand landscape */
+void SetScreenMode(int mode);
+int GetScreenMode();
+void drawWait();
+
+void Translate(int* x, int* y);
+
+typedef enum ToolbarSelected {
+	ToolbarNone,
+	ToolbarSaveLoad,
+	ToolbarMode,
+	ToolbarSkip,
+	ToolbarSound
+} ToolbarSelected;
+	
+
+#endif
diff --git a/backends/x11/x11.cpp b/backends/x11/x11.cpp
new file mode 100644
index 0000000000..2ebbe96193
--- /dev/null
+++ b/backends/x11/x11.cpp
@@ -0,0 +1,990 @@
+/* ScummVM - Scumm Interpreter
+ * Copyright (C) 2001  Ludvig Strigeus
+ * Copyright (C) 2001/2002 The ScummVM project
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ *
+ * $Header$
+ *
+ */
+
+/* The bare pure X11 port done by Lionel 'BBrox' Ulmer */
+
+#include "stdafx.h"
+#include "scumm.h"
+#include "mididrv.h"
+#include "gameDetector.h"
+
+#include <sys/time.h>
+#include <unistd.h>
+
+#include <sys/ipc.h>
+#include <sys/shm.h>
+
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/XShm.h>
+#ifdef USE_XV_SCALING
+#include <X11/extensions/Xv.h>
+#include <X11/extensions/Xvlib.h>
+#endif
+#include <linux/soundcard.h>
+
+#include <sched.h>
+#include <pthread.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+
+class OSystem_X11:public OSystem {
+public:
+	// Set colors of the palette
+	void set_palette(const byte *colors, uint start, uint num);
+
+	// Set the size of the video bitmap.
+	// Typically, 320x200
+	void init_size(uint w, uint h);
+
+	// Draw a bitmap to screen.
+	// The screen will not be updated to reflect the new bitmap
+	void copy_rect(const byte *buf, int pitch, int x, int y, int w, int h);
+
+	// Update the dirty areas of the screen
+	void update_screen();
+
+	// Either show or hide the mouse cursor
+	bool show_mouse(bool visible);
+
+	// Set the position of the mouse cursor
+	void set_mouse_pos(int x, int y);
+
+	// Set the bitmap that's used when drawing the cursor.
+	void set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y);
+
+	// Shaking is used in SCUMM. Set current shake position.
+	void set_shake_pos(int shake_pos);
+
+	// Get the number of milliseconds since the program was started.
+	uint32 get_msecs();
+
+	// Delay for a specified amount of milliseconds
+	void delay_msecs(uint msecs);
+
+	// Create a thread
+	void *create_thread(ThreadProc *proc, void *param);
+
+	// Get the next event.
+	// Returns true if an event was retrieved.  
+	bool poll_event(Event *event);
+
+	// Set function that generates samples 
+	bool set_sound_proc(void *param, SoundProc *proc, byte sound);
+
+	// Poll cdrom status
+	// Returns true if cd audio is playing
+	bool poll_cdrom();
+
+	// Play cdrom audio track
+	void play_cdrom(int track, int num_loops, int start_frame, int end_frame);
+
+	// Stop cdrom audio track
+	void stop_cdrom();
+
+	// Update cdrom audio status
+	void update_cdrom();
+
+	// Quit
+	void quit();
+
+	// Set a parameter
+	uint32 property(int param, Property *value);
+
+	// Add a callback timer
+	void set_timer(int timer, int (*callback) (int));
+
+	// Mutex handling
+	void *create_mutex(void);
+	void lock_mutex(void *mutex);
+	void unlock_mutex(void *mutex);
+	void delete_mutex(void *mutex);
+
+	static OSystem *create(int gfx_mode, bool full_screen);
+
+private:
+	  OSystem_X11();
+
+	typedef struct {
+		int x, y, w, h;
+	} dirty_square;
+
+	void create_empty_cursor();
+	void undraw_mouse();
+	void draw_mouse();
+	void update_screen_helper(const dirty_square * d, dirty_square * dout);
+
+	unsigned char *local_fb;
+
+	int window_width, window_height;
+	int fb_width, fb_height;
+	int scumm_x, scumm_y;
+
+#ifdef USE_XV_SCALING
+	unsigned int *palette;
+#else
+	unsigned short *palette;
+#endif
+	bool _palette_changed;
+	Display *display;
+	int screen;
+	Window window;
+	GC black_gc;
+#ifdef USE_XV_SCALING
+	XvImage *image;
+#else
+	XImage *image;
+#endif
+	pthread_t sound_thread;
+
+	int fake_right_mouse;
+	int report_presses;
+	int current_shake_pos;
+	int new_shake_pos;
+	struct timeval start_time;
+
+	enum {
+		MAX_NUMBER_OF_DIRTY_SQUARES = 32,
+		BAK_WIDTH = 40,
+		BAK_HEIGHT = 40
+	};
+	dirty_square ds[MAX_NUMBER_OF_DIRTY_SQUARES];
+	int num_of_dirty_square;
+
+	typedef struct {
+		int x, y;
+		int w, h;
+		int hot_x, hot_y;
+	} mouse_state;
+	mouse_state old_state, cur_state;
+	const byte *_ms_buf;
+	byte _ms_backup[BAK_WIDTH * BAK_HEIGHT];
+	bool _mouse_drawn;
+	bool _mouse_visible;
+
+	unsigned int _timer_duration, _timer_next_expiry;
+	bool _timer_active;
+	int (*_timer_callback) (int);
+};
+
+typedef struct {
+	OSystem::SoundProc *sound_proc;
+	void *param;
+	byte format;
+} THREAD_PARAM;
+
+#undef CAPTURE_SOUND
+
+#define FRAG_SIZE 4096
+static void *sound_and_music_thread(void *params)
+{
+	/* Init sound */
+	int sound_fd, param, frag_size;
+	unsigned char sound_buffer[FRAG_SIZE];
+	OSystem::SoundProc *sound_proc = ((THREAD_PARAM *) params)->sound_proc;
+	void *proc_param = ((THREAD_PARAM *) params)->param;
+
+#ifdef CAPTURE_SOUND
+	FILE *f = fopen("sound.raw", "wb");
+#endif
+
+	sound_fd = open("/dev/dsp", O_WRONLY);
+	audio_buf_info info;
+	if (sound_fd < 0) {
+		error("Error opening sound device !\n");
+		exit(1);
+	}
+	param = 0;
+	frag_size = FRAG_SIZE /* audio fragment size */ ;
+	while (frag_size) {
+		frag_size >>= 1;
+		param++;
+	}
+	param--;
+	param |= /* audio_fragment_num */ 3 << 16;
+	if (ioctl(sound_fd, SNDCTL_DSP_SETFRAGMENT, &param) != 0) {
+		error("Error in the SNDCTL_DSP_SETFRAGMENT ioctl !\n");
+		exit(1);
+	}
+	param = AFMT_S16_LE;
+	if (ioctl(sound_fd, SNDCTL_DSP_SETFMT, &param) == -1) {
+		perror("Error in the SNDCTL_DSP_SETFMT ioctl !\n");
+		exit(1);
+	}
+	if (param != AFMT_S16_LE) {
+		error("AFMT_S16_LE not supported !\n");
+		exit(1);
+	}
+	param = 2;
+	if (ioctl(sound_fd, SNDCTL_DSP_CHANNELS, &param) == -1) {
+		error("Error in the SNDCTL_DSP_CHANNELS ioctl !\n");
+		exit(1);
+	}
+	if (param != 2) {
+		error("Stereo mode not supported !\n");
+		exit(1);
+	}
+	param = 22050;
+	if (ioctl(sound_fd, SNDCTL_DSP_SPEED, &param) == -1) {
+		perror("Error in the SNDCTL_DSP_SPEED ioctl !\n");
+		exit(1);
+	}
+	if (param != 22050) {
+		error("22050 kHz not supported !\n");
+		exit(1);
+	}
+	if (ioctl(sound_fd, SNDCTL_DSP_GETOSPACE, &info) != 0) {
+		perror("SNDCTL_DSP_GETOSPACE");
+		exit(-1);
+	}
+
+	sched_yield();
+	while (1) {
+		unsigned char *buf = (unsigned char *)sound_buffer;
+		int size, written;
+
+		sound_proc(proc_param, (byte *)sound_buffer, FRAG_SIZE);
+#ifdef CAPTURE_SOUND
+		fwrite(buf, 2, FRAG_SIZE >> 1, f);
+		fflush(f);
+#endif
+		size = FRAG_SIZE;
+		while (size > 0) {
+			written = write(sound_fd, buf, size);
+			buf += written;
+			size -= written;
+		}
+	}
+
+	return NULL;
+}
+
+/* Function used to hide the mouse cursor */
+void OSystem_X11::create_empty_cursor()
+{
+	XColor bg;
+	Pixmap pixmapBits;
+	Cursor cursor = None;
+	static const char data[] = { 0 };
+
+	bg.red = bg.green = bg.blue = 0x0000;
+	pixmapBits = XCreateBitmapFromData(display, XRootWindow(display, screen), data, 1, 1);
+	if (pixmapBits) {
+		cursor = XCreatePixmapCursor(display, pixmapBits, pixmapBits, &bg, &bg, 0, 0);
+		XFreePixmap(display, pixmapBits);
+	}
+	XDefineCursor(display, window, cursor);
+}
+
+OSystem *OSystem_X11_create(void)
+{
+	return OSystem_X11::create(0, 0);
+}
+
+OSystem *OSystem_X11::create(int gfx_mode, bool full_screen)
+{
+	OSystem_X11 *syst = new OSystem_X11();
+	return syst;
+}
+
+OSystem_X11::OSystem_X11()
+{
+	char buf[512];
+	XWMHints *wm_hints;
+	XGCValues values;
+	XTextProperty window_name;
+	char *name = (char *)&buf;
+
+	/* Some members initialization */
+	fake_right_mouse = 0;
+	report_presses = 1;
+	current_shake_pos = 0;
+	new_shake_pos = 0;
+	_palette_changed = false;
+	num_of_dirty_square = MAX_NUMBER_OF_DIRTY_SQUARES;
+
+	/* For the window title */
+	sprintf(buf, "ScummVM");
+
+	display = XOpenDisplay(NULL);
+	if (display == NULL) {
+		error("Could not open display !\n");
+		exit(1);
+	}
+	screen = DefaultScreen(display);
+
+	window_width = 320;
+	window_height = 200;
+	scumm_x = 0;
+	scumm_y = 0;
+	window = XCreateSimpleWindow(display, XRootWindow(display, screen), 0, 0, 320, 200, 0, 0, 0);
+	wm_hints = XAllocWMHints();
+	if (wm_hints == NULL) {
+		error("Not enough memory to allocate Hints !\n");
+		exit(1);
+	}
+	wm_hints->flags = InputHint | StateHint;
+	wm_hints->input = True;
+	wm_hints->initial_state = NormalState;
+	XStringListToTextProperty(&name, 1, &window_name);
+	XSetWMProperties(display, window, &window_name, &window_name,
+									 NULL /* argv */ , 0 /* argc */ , NULL /* size hints */ ,
+									 wm_hints, NULL /* class hints */ );
+	XFree(wm_hints);
+
+	XSelectInput(display, window,
+							 ExposureMask | KeyPressMask | KeyReleaseMask |
+							 PointerMotionMask | ButtonPressMask | ButtonReleaseMask | StructureNotifyMask);
+
+	values.foreground = BlackPixel(display, screen);
+	black_gc = XCreateGC(display, window, GCForeground, &values);
+
+	XMapWindow(display, window);
+	XFlush(display);
+
+	while (1) {
+		XEvent event;
+		XNextEvent(display, &event);
+		switch (event.type) {
+		case Expose:
+			goto out_of_loop;
+		}
+	}
+out_of_loop:
+	create_empty_cursor();
+
+	/* Initialize the timer routines */
+	_timer_active = false;
+
+	/* And finally start the local timer */
+	gettimeofday(&start_time, NULL);
+}
+
+uint32 OSystem_X11::get_msecs()
+{
+	struct timeval current_time;
+	gettimeofday(&current_time, NULL);
+	return (uint32)(((current_time.tv_sec - start_time.tv_sec) * 1000) +
+									((current_time.tv_usec - start_time.tv_usec) / 1000));
+}
+
+void OSystem_X11::init_size(uint w, uint h)
+{
+	static XShmSegmentInfo shminfo;
+
+	fb_width = w;
+	fb_height = h;
+
+	if ((fb_width != 320) || (fb_height != 200)) {
+		/* We need to change the size of the X11 window */
+		XWindowChanges new_values;
+
+		new_values.width = fb_width;
+		new_values.height = fb_height;
+
+		XConfigureWindow(display, window, CWWidth | CWHeight, &new_values);
+	}
+#ifdef USE_XV_SCALING
+	image = XvShmCreateImage(display, 65, 0x03, 0, fb_width, fb_height, &shminfo);
+	shminfo.shmid = shmget(IPC_PRIVATE, image->data_size, IPC_CREAT | 0700);
+#else
+	image =
+		XShmCreateImage(display, DefaultVisual(display, screen), 16, ZPixmap, NULL, &shminfo, fb_width,
+										fb_height);
+	shminfo.shmid = shmget(IPC_PRIVATE, fb_width * fb_height * 2, IPC_CREAT | 0700);
+#endif
+	shminfo.shmaddr = (char *)shmat(shminfo.shmid, 0, 0);
+	image->data = shminfo.shmaddr;
+	shminfo.readOnly = False;
+	if (XShmAttach(display, &shminfo) == 0) {
+		error("Could not attach shared memory segment !\n");
+		exit(1);
+	}
+	shmctl(shminfo.shmid, IPC_RMID, 0);
+
+	/* Initialize the 'local' frame buffer and the palette */
+	local_fb = (unsigned char *)calloc(fb_width * fb_height, sizeof(unsigned char));
+#ifdef USE_XV_SCALING
+	palette = (unsigned int *)calloc(256, sizeof(unsigned int));
+#else
+	palette = (unsigned short *)calloc(256, sizeof(unsigned short));
+#endif
+}
+
+bool OSystem_X11::set_sound_proc(void *param, SoundProc *proc, byte format)
+{
+	static THREAD_PARAM thread_param;
+
+	/* And finally start the music thread */
+	thread_param.param = param;
+	thread_param.sound_proc = proc;
+	thread_param.format = format;
+
+	if (format == SOUND_16BIT)
+		pthread_create(&sound_thread, NULL, sound_and_music_thread, (void *)&thread_param);
+	else
+		warning("Only support 16 bit sound for now. Disabling sound ");
+
+	return true;
+}
+
+void OSystem_X11::set_palette(const byte *colors, uint start, uint num)
+{
+	const byte *data = colors;
+#ifdef USE_XV_SCALING
+	unsigned int *pal = &(palette[start]);
+#else
+	unsigned short *pal = &(palette[start]);
+#endif
+
+	do {
+#ifdef USE_XV_SCALING
+		*pal++ = (data[0] << 16) | (data[1] << 8) | data[2];
+#else
+		*pal++ = ((data[0] & 0xF8) << 8) | ((data[1] & 0xFC) << 3) | (data[2] >> 3);
+#endif
+		data += 4;
+		num--;
+	} while (num > 0);
+
+	_palette_changed = true;
+}
+
+#define AddDirtyRec(xi,yi,wi,hi) 				\
+  if (num_of_dirty_square < MAX_NUMBER_OF_DIRTY_SQUARES) {	\
+    ds[num_of_dirty_square].x = xi;				\
+    ds[num_of_dirty_square].y = yi;				\
+    ds[num_of_dirty_square].w = wi;				\
+    ds[num_of_dirty_square].h = hi;				\
+    num_of_dirty_square++;					\
+  }
+
+void OSystem_X11::copy_rect(const byte *buf, int pitch, int x, int y, int w, int h)
+{
+	unsigned char *dst;
+
+	if (y < 0) {
+		h += y;
+		buf -= y * pitch;
+		y = 0;
+	}
+	if (h > (fb_height - y)) {
+		h = fb_height - y;
+	}
+
+	dst = local_fb + fb_width * y + x;
+
+	if (h <= 0)
+		return;
+
+	if (_mouse_drawn)
+		undraw_mouse();
+
+	AddDirtyRec(x, y, w, h);
+	while (h-- > 0) {
+		memcpy(dst, buf, w);
+		dst += fb_width;
+		buf += pitch;
+	}
+}
+
+void OSystem_X11::update_screen_helper(const dirty_square * d, dirty_square * dout)
+{
+	int x, y;
+	unsigned char *ptr_src = local_fb + (fb_width * d->y) + d->x;
+#ifdef USE_XV_SCALING
+	unsigned int *ptr_dst = ((unsigned int *)image->data) + (fb_width * d->y) + d->x;
+#else
+	unsigned short *ptr_dst = ((unsigned short *)image->data) + (fb_width * d->y) + d->x;
+#endif
+
+	for (y = 0; y < d->h; y++) {
+		for (x = 0; x < d->w; x++) {
+			*ptr_dst++ = palette[*ptr_src++];
+		}
+		ptr_dst += fb_width - d->w;
+		ptr_src += fb_width - d->w;
+	}
+	if (d->x < dout->x)
+		dout->x = d->x;
+	if (d->y < dout->y)
+		dout->y = d->y;
+	if ((d->x + d->w) > dout->w)
+		dout->w = d->x + d->w;
+	if ((d->y + d->h) > dout->h)
+		dout->h = d->y + d->h;
+}
+
+void OSystem_X11::update_screen()
+{
+	bool full_redraw = false;
+	bool need_redraw = false;
+	static const dirty_square ds_full = { 0, 0, fb_width, fb_height };
+	dirty_square dout = { fb_width, fb_height, 0, 0 };
+
+	/* First make sure the mouse is drawn, if it should be drawn. */
+	draw_mouse();
+
+	if (_palette_changed) {
+		full_redraw = true;
+		num_of_dirty_square = 0;
+		_palette_changed = false;
+	} else if (num_of_dirty_square >= MAX_NUMBER_OF_DIRTY_SQUARES) {
+		full_redraw = true;
+		num_of_dirty_square = 0;
+	}
+
+	if (full_redraw) {
+		update_screen_helper(&ds_full, &dout);
+		need_redraw = true;
+	} else if (num_of_dirty_square > 0) {
+		need_redraw = true;
+		while (num_of_dirty_square > 0) {
+			num_of_dirty_square--;
+			update_screen_helper(&(ds[num_of_dirty_square]), &dout);
+		}
+	}
+
+	if (current_shake_pos != new_shake_pos) {
+		/* Redraw first the 'black borders' in case of resize */
+		if (current_shake_pos < new_shake_pos)
+			XFillRectangle(display, window, black_gc, 0, current_shake_pos, window_width, new_shake_pos);
+		else
+			XFillRectangle(display, window, black_gc, 0, window_height - current_shake_pos,
+										 window_width, window_height - new_shake_pos);
+#ifndef USE_XV_SCALING
+		XShmPutImage(display, window, DefaultGC(display, screen), image,
+								 0, 0, scumm_x, scumm_y + new_shake_pos, fb_width, fb_height, 0);
+#endif
+		current_shake_pos = new_shake_pos;
+	} else if (need_redraw == true) {
+#ifdef USE_XV_SCALING
+		XvShmPutImage(display, 65, window, DefaultGC(display, screen), image,
+									0, 0, fb_width, fb_height, 0, 0, window_width, window_height, 0);
+#else
+		XShmPutImage(display, window, DefaultGC(display, screen), image,
+								 dout.x, dout.y, scumm_x + dout.x, scumm_y + dout.y + current_shake_pos,
+								 dout.w - dout.x, dout.h - dout.y, 0);
+#endif
+		XFlush(display);
+	}
+}
+
+bool OSystem_X11::show_mouse(bool visible)
+{
+	if (_mouse_visible == visible)
+		return visible;
+
+	bool last = _mouse_visible;
+	_mouse_visible = visible;
+
+	if (visible)
+		draw_mouse();
+	else
+		undraw_mouse();
+
+	return last;
+}
+
+void OSystem_X11::quit()
+{
+	exit(1);
+}
+
+void OSystem_X11::draw_mouse()
+{
+	if (_mouse_drawn || !_mouse_visible)
+		return;
+	_mouse_drawn = true;
+
+	int xdraw = cur_state.x - cur_state.hot_x;
+	int ydraw = cur_state.y - cur_state.hot_y;
+	int w = cur_state.w;
+	int h = cur_state.h;
+	int real_w;
+	int real_h;
+	int real_h_2;
+
+	byte *dst;
+	byte *dst2;
+	const byte *buf = _ms_buf;
+	byte *bak = _ms_backup;
+
+	assert(w <= BAK_WIDTH && h <= BAK_HEIGHT);
+
+	if (ydraw < 0) {
+		real_h = h + ydraw;
+		buf += (-ydraw) * w;
+		ydraw = 0;
+	} else {
+		real_h = (ydraw + h) > fb_height ? (fb_height - ydraw) : h;
+	}
+	if (xdraw < 0) {
+		real_w = w + xdraw;
+		buf += (-xdraw);
+		xdraw = 0;
+	} else {
+		real_w = (xdraw + w) > fb_width ? (fb_width - xdraw) : w;
+	}
+
+	dst = local_fb + (ydraw * fb_width) + xdraw;
+	dst2 = dst;
+
+	if ((real_h == 0) || (real_w == 0)) {
+		_mouse_drawn = false;
+		return;
+	}
+
+	AddDirtyRec(xdraw, ydraw, real_w, real_h);
+	old_state.x = xdraw;
+	old_state.y = ydraw;
+	old_state.w = real_w;
+	old_state.h = real_h;
+
+	real_h_2 = real_h;
+	while (real_h_2 > 0) {
+		memcpy(bak, dst, real_w);
+		bak += BAK_WIDTH;
+		dst += fb_width;
+		real_h_2--;
+	}
+	while (real_h > 0) {
+		int width = real_w;
+		while (width > 0) {
+			byte color = *buf;
+			if (color != 0xFF) {
+				*dst2 = color;
+			}
+			buf++;
+			dst2++;
+			width--;
+		}
+		buf += w - real_w;
+		dst2 += fb_width - real_w;
+		real_h--;
+	}
+}
+
+void OSystem_X11::undraw_mouse()
+{
+	if (!_mouse_drawn)
+		return;
+	_mouse_drawn = false;
+
+	int old_h = old_state.h;
+
+	AddDirtyRec(old_state.x, old_state.y, old_state.w, old_state.h);
+
+	byte *dst = local_fb + (old_state.y * fb_width) + old_state.x;
+	byte *bak = _ms_backup;
+
+	while (old_h > 0) {
+		memcpy(dst, bak, old_state.w);
+		bak += BAK_WIDTH;
+		dst += fb_width;
+		old_h--;
+	}
+}
+
+void OSystem_X11::set_mouse_pos(int x, int y)
+{
+	if ((x != cur_state.x) || (y != cur_state.y)) {
+		cur_state.x = x;
+		cur_state.y = y;
+		undraw_mouse();
+	}
+}
+
+void OSystem_X11::set_mouse_cursor(const byte *buf, uint w, uint h, int hotspot_x, int hotspot_y)
+{
+	cur_state.w = w;
+	cur_state.h = h;
+	cur_state.hot_x = hotspot_x;
+	cur_state.hot_y = hotspot_y;
+	_ms_buf = (byte *)buf;
+
+	undraw_mouse();
+}
+
+void OSystem_X11::set_shake_pos(int shake_pos)
+{
+	new_shake_pos = shake_pos;
+}
+
+void *OSystem_X11::create_thread(ThreadProc *proc, void *param)
+{
+	pthread_t *thread = (pthread_t *) malloc(sizeof(pthread_t));
+	if (pthread_create(thread, NULL, (void *(*)(void *))proc, param))
+		return NULL;
+	else
+		return thread;
+}
+
+uint32 OSystem_X11::property(int param, Property *value)
+{
+	switch (param) {
+	case PROP_GET_SAMPLE_RATE:
+		return 22050;
+	case PROP_GET_FULLSCREEN:
+		return 0;
+	}
+	warning("Property not implemented yet (%d) ", param);
+	return 0;
+}
+
+bool OSystem_X11::poll_cdrom()
+{
+	return false;
+}
+
+void OSystem_X11::play_cdrom(int track, int num_loops, int start_frame, int end_frame)
+{
+}
+
+void OSystem_X11::stop_cdrom()
+{
+}
+
+void OSystem_X11::update_cdrom()
+{
+}
+
+void OSystem_X11::delay_msecs(uint msecs)
+{
+	usleep(msecs * 1000);
+}
+
+bool OSystem_X11::poll_event(Event *scumm_event)
+{
+	/* First, handle timers */
+	uint32 current_msecs = get_msecs();
+
+	if (_timer_active && (current_msecs >= _timer_next_expiry)) {
+		_timer_duration = _timer_callback(_timer_duration);
+		_timer_next_expiry = current_msecs + _timer_duration;
+	}
+
+	while (XPending(display)) {
+		XEvent event;
+
+		XNextEvent(display, &event);
+		switch (event.type) {
+		case Expose:{
+				int real_w, real_h;
+				int real_x, real_y;
+				real_x = event.xexpose.x;
+				real_y = event.xexpose.y;
+				real_w = event.xexpose.width;
+				real_h = event.xexpose.height;
+				if (real_x < scumm_x) {
+					real_w -= scumm_x - real_x;
+					real_x = 0;
+				} else {
+					real_x -= scumm_x;
+				}
+				if (real_y < scumm_y) {
+					real_h -= scumm_y - real_y;
+					real_y = 0;
+				} else {
+					real_y -= scumm_y;
+				}
+				if ((real_h <= 0) || (real_w <= 0))
+					break;
+				if ((real_x >= fb_width) || (real_y >= fb_height))
+					break;
+
+				if ((real_x + real_w) >= fb_width) {
+					real_w = fb_width - real_x;
+				}
+				if ((real_y + real_h) >= fb_height) {
+					real_h = fb_height - real_y;
+				}
+
+				/* Compute the intersection of the expose event with the real ScummVM display zone */
+				AddDirtyRec(real_x, real_y, real_w, real_h);
+			}
+			break;
+
+		case KeyPress:
+			switch (event.xkey.keycode) {
+			case 132:
+				report_presses = 0;
+				break;
+
+			case 133:
+				fake_right_mouse = 1;
+				break;
+			}
+			break;
+
+		case KeyRelease:{
+				/* I am using keycodes here and NOT keysyms to be sure that even if the user
+				   remaps his iPAQ's keyboard, it will still work.
+				 */
+				int keycode = -1;
+				int ascii = -1;
+				byte mode = 0;
+
+				if (event.xkey.state & 0x01)
+					mode |= KBD_SHIFT;
+				if (event.xkey.state & 0x04)
+					mode |= KBD_CTRL;
+				if (event.xkey.state & 0x08)
+					mode |= KBD_ALT;
+				switch (event.xkey.keycode) {
+				case 9:								/* Escape on my PC */
+				case 130:							/* Calendar on the iPAQ */
+					keycode = 27;
+					break;
+
+				case 71:								/* F5 on my PC */
+				case 128:							/* Record on the iPAQ */
+					keycode = 319;
+					break;
+
+				case 65:								/* Space on my PC */
+				case 131:							/* Schedule on the iPAQ */
+					keycode = 32;
+					break;
+
+				case 132:							/* 'Q' on the iPAQ */
+					report_presses = 1;
+					break;
+
+				case 133:							/* Arrow on the iPAQ */
+					fake_right_mouse = 0;
+					break;
+
+				default:{
+						KeySym xsym;
+						xsym = XKeycodeToKeysym(display, event.xkey.keycode, 0);
+						keycode = xsym;
+						if ((xsym >= 'a') && (xsym <= 'z') && (event.xkey.state & 0x01))
+							xsym &= ~0x20;		/* Handle shifted keys */
+						ascii = xsym;
+					}
+				}
+				if (keycode != -1) {
+					scumm_event->event_code = EVENT_KEYDOWN;
+					scumm_event->kbd.keycode = keycode;
+					scumm_event->kbd.ascii = (ascii != -1 ? ascii : keycode);
+					scumm_event->kbd.flags = mode;
+					return true;
+				}
+			}
+			break;
+
+		case ButtonPress:
+			if (report_presses != 0) {
+				if (event.xbutton.button == 1) {
+					if (fake_right_mouse == 0) {
+						scumm_event->event_code = EVENT_LBUTTONDOWN;
+					} else {
+						scumm_event->event_code = EVENT_RBUTTONDOWN;
+					}
+				} else if (event.xbutton.button == 3)
+					scumm_event->event_code = EVENT_RBUTTONDOWN;
+				scumm_event->mouse.x = event.xbutton.x - scumm_x;
+				scumm_event->mouse.y = event.xbutton.y - scumm_y;
+				return true;
+			}
+			break;
+
+		case ButtonRelease:
+			if (report_presses != 0) {
+				if (event.xbutton.button == 1) {
+					if (fake_right_mouse == 0) {
+						scumm_event->event_code = EVENT_LBUTTONUP;
+					} else {
+						scumm_event->event_code = EVENT_RBUTTONUP;
+					}
+				} else if (event.xbutton.button == 3)
+					scumm_event->event_code = EVENT_RBUTTONUP;
+				scumm_event->mouse.x = event.xbutton.x - scumm_x;
+				scumm_event->mouse.y = event.xbutton.y - scumm_y;
+				return true;
+			}
+			break;
+
+		case MotionNotify:
+			scumm_event->event_code = EVENT_MOUSEMOVE;
+			scumm_event->mouse.x = event.xmotion.x - scumm_x;
+			scumm_event->mouse.y = event.xmotion.y - scumm_y;
+			return true;
+
+		case ConfigureNotify:{
+				if ((window_width != event.xconfigure.width) || (window_height != event.xconfigure.height)) {
+					window_width = event.xconfigure.width;
+					window_height = event.xconfigure.height;
+					scumm_x = (window_width - fb_width) / 2;
+					scumm_y = (window_height - fb_height) / 2;
+					XFillRectangle(display, window, black_gc, 0, 0, window_width, window_height);
+				}
+			}
+			break;
+
+		default:
+			printf("Unhandled event : %d\n", event.type);
+			break;
+		}
+	}
+
+	return false;
+}
+
+void OSystem_X11::set_timer(int timer, int (*callback) (int))
+{
+	if (callback != NULL) {
+		_timer_duration = timer;
+		_timer_next_expiry = get_msecs() + timer;
+		_timer_callback = callback;
+		_timer_active = true;
+	} else {
+		_timer_active = false;
+	}
+}
+
+void *OSystem_X11::create_mutex(void)
+{
+	pthread_mutex_t *mutex = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
+	pthread_mutex_init(mutex, NULL);
+	return (void *)mutex;
+}
+
+void OSystem_X11::lock_mutex(void *mutex)
+{
+	pthread_mutex_lock((pthread_mutex_t *) mutex);
+}
+
+void OSystem_X11::unlock_mutex(void *mutex)
+{
+	pthread_mutex_unlock((pthread_mutex_t *) mutex);
+}
+
+void OSystem_X11::delete_mutex(void *mutex)
+{
+	pthread_mutex_destroy((pthread_mutex_t *) mutex);
+	free(mutex);
+}