From ce46866403fdcc479cf9d67e4d430409b15dadc3 Mon Sep 17 00:00:00 2001 From: Max Horn Date: Wed, 21 Aug 2002 16:07:07 +0000 Subject: Initial revision svn-id: r4785 --- backends/dc/.cvsignore | 5 + backends/dc/Makefile | 39 + backends/dc/README | 20 + backends/dc/audio.cpp | 86 + backends/dc/dc.h | 102 + backends/dc/dcmain.cpp | 201 + backends/dc/display.cpp | 303 + backends/dc/icon.cpp | 228 + backends/dc/icon.h | 21 + backends/dc/input.cpp | 173 + backends/dc/label.cpp | 131 + backends/dc/label.h | 11 + backends/dc/portdefs.h | 9 + backends/dc/selector.cpp | 487 ++ backends/dc/vmsave.cpp | 266 + backends/mac/Carbon.r | 111 + backends/mac/CarbonPort-ReadMe.txt | 34 + backends/mac/mac.cpp | 1790 ++++++ backends/mac/macos.h | 24 + backends/mac/scummvm.icns | Bin 0 -> 38332 bytes backends/mac/scummvm.mcp | Bin 0 -> 158716 bytes backends/morphos/Makefile | 48 + backends/morphos/MorphOS.readme | 13 + backends/morphos/morphos.cpp | 1293 ++++ backends/morphos/morphos.h | 206 + backends/morphos/morphos_scaler.cpp | 823 +++ backends/morphos/morphos_scaler.h | 93 + backends/morphos/morphos_sound.cpp | 284 + backends/morphos/morphos_start.cpp | 359 ++ backends/morphos/morphos_timer.cpp | 243 + backends/morphos/morphos_timer.h | 86 + backends/sdl/fb2opengl.h | 355 ++ backends/sdl/sdl.cpp | 1409 +++++ backends/sdl/sdl_gl.cpp | 1068 ++++ backends/wince/MenuTitle.bmp | Bin 0 -> 11482 bytes backends/wince/PocketSCUMM.rc | 209 + backends/wince/PocketSCUMM.vcc | 74 + backends/wince/PocketSCUMM.vcp | 9228 +++++++++++++++++++++++++++++ backends/wince/PocketSCUMM.vcw | 29 + backends/wince/bitmaps.cpp | 10720 ++++++++++++++++++++++++++++++++++ backends/wince/findgame.cpp | 556 ++ backends/wince/gapi_keys.cpp | 341 ++ backends/wince/gapi_keys.h | 62 + backends/wince/missing/assert.h | 3 + backends/wince/missing/conio.h | 2 + backends/wince/missing/dir.h | 1 + backends/wince/missing/direct.h | 1 + backends/wince/missing/dirent.h | 52 + backends/wince/missing/errno.h | 1 + backends/wince/missing/fcntl.h | 1 + backends/wince/missing/io.h | 15 + backends/wince/missing/missing.cpp | 378 ++ backends/wince/missing/signal.h | 3 + backends/wince/missing/sys/stat.h | 23 + backends/wince/missing/sys/time.h | 10 + backends/wince/missing/sys/types.h | 5 + backends/wince/missing/time.h | 24 + backends/wince/missing/unistd.h | 1 + backends/wince/newres.h | 41 + backends/wince/pocketpc.cpp | 1490 +++++ backends/wince/pocketscumm.ico | Bin 0 -> 318 bytes backends/wince/resource.h | 58 + backends/wince/screen.cpp | 1588 +++++ backends/wince/screen.h | 58 + backends/x11/x11.cpp | 990 ++++ 65 files changed, 36285 insertions(+) create mode 100644 backends/dc/.cvsignore create mode 100644 backends/dc/Makefile create mode 100644 backends/dc/README create mode 100644 backends/dc/audio.cpp create mode 100644 backends/dc/dc.h create mode 100644 backends/dc/dcmain.cpp create mode 100644 backends/dc/display.cpp create mode 100644 backends/dc/icon.cpp create mode 100644 backends/dc/icon.h create mode 100644 backends/dc/input.cpp create mode 100644 backends/dc/label.cpp create mode 100644 backends/dc/label.h create mode 100644 backends/dc/portdefs.h create mode 100644 backends/dc/selector.cpp create mode 100644 backends/dc/vmsave.cpp create mode 100644 backends/mac/Carbon.r create mode 100644 backends/mac/CarbonPort-ReadMe.txt create mode 100644 backends/mac/mac.cpp create mode 100644 backends/mac/macos.h create mode 100644 backends/mac/scummvm.icns create mode 100644 backends/mac/scummvm.mcp create mode 100644 backends/morphos/Makefile create mode 100644 backends/morphos/MorphOS.readme create mode 100644 backends/morphos/morphos.cpp create mode 100644 backends/morphos/morphos.h create mode 100644 backends/morphos/morphos_scaler.cpp create mode 100644 backends/morphos/morphos_scaler.h create mode 100644 backends/morphos/morphos_sound.cpp create mode 100644 backends/morphos/morphos_start.cpp create mode 100644 backends/morphos/morphos_timer.cpp create mode 100644 backends/morphos/morphos_timer.h create mode 100644 backends/sdl/fb2opengl.h create mode 100644 backends/sdl/sdl.cpp create mode 100644 backends/sdl/sdl_gl.cpp create mode 100644 backends/wince/MenuTitle.bmp create mode 100644 backends/wince/PocketSCUMM.rc create mode 100644 backends/wince/PocketSCUMM.vcc create mode 100644 backends/wince/PocketSCUMM.vcp create mode 100644 backends/wince/PocketSCUMM.vcw create mode 100644 backends/wince/bitmaps.cpp create mode 100644 backends/wince/findgame.cpp create mode 100644 backends/wince/gapi_keys.cpp create mode 100644 backends/wince/gapi_keys.h create mode 100644 backends/wince/missing/assert.h create mode 100644 backends/wince/missing/conio.h create mode 100644 backends/wince/missing/dir.h create mode 100644 backends/wince/missing/direct.h create mode 100644 backends/wince/missing/dirent.h create mode 100644 backends/wince/missing/errno.h create mode 100644 backends/wince/missing/fcntl.h create mode 100644 backends/wince/missing/io.h create mode 100644 backends/wince/missing/missing.cpp create mode 100644 backends/wince/missing/signal.h create mode 100644 backends/wince/missing/sys/stat.h create mode 100644 backends/wince/missing/sys/time.h create mode 100644 backends/wince/missing/sys/types.h create mode 100644 backends/wince/missing/time.h create mode 100644 backends/wince/missing/unistd.h create mode 100644 backends/wince/newres.h create mode 100644 backends/wince/pocketpc.cpp create mode 100644 backends/wince/pocketscumm.ico create mode 100644 backends/wince/resource.h create mode 100644 backends/wince/screen.cpp create mode 100644 backends/wince/screen.h create mode 100644 backends/x11/x11.cpp (limited to 'backends') 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 : + +* libronin-0.3 : + +* 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 + +#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))mouse.x, oldmousey = s->mouse.y; + time = (((unsigned int)time)*100000U)>>11; + int mask = getimask(); + while(((int)((t = Timer())-start))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>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 +#include + +#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<>= 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=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 +#include + +#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; u0) + 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 +#include +#include +#include +#include +#include +#include +#include +#include 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 + + +#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; id_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= 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=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) + 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 + + +// 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: + * + * + */ + +#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 +#include + +#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 Binary files /dev/null and b/backends/mac/scummvm.icns differ diff --git a/backends/mac/scummvm.mcp b/backends/mac/scummvm.mcp new file mode 100644 index 0000000000..41a29050f4 Binary files /dev/null and b/backends/mac/scummvm.mcp differ 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#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 > 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= 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 +#include +#include +#include +#include +#include + +#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 +#include + +#include + +#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 + +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 +#include +#include +#include + +#include +#include +#include +#include + +#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 +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#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 +#include +#include +#include + +#include +#include +#include + +#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 +#endif + +#ifndef EXEC_IO_H +#include +#endif + +#ifndef EXEC_SEMAPHORES_H +#include +#endif + +#ifndef DOS_DOSEXTENS_H +#include +#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 + +#include +#include +#include +#include + +// 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 +#include + + +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 +#include + +#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 Binary files /dev/null and b/backends/wince/MenuTitle.bmp differ 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 +#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 +#include +#include +#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; iget("BasePath", "wince"); + if (!current) + return FALSE; + MultiByteToWideChar(CP_ACP, 0, current, strlen(current) + 1, basePath, sizeof(basePath)); + + for (i=0; iget(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; iset("GamesInstalled", index, "wince"); + + tempo[0] = '\0'; + for (i=0; iset("GamesReferences", tempo, "wince"); + + WideCharToMultiByte(CP_ACP, 0, basePath, wcslen(basePath) + 1, workdir, sizeof(workdir), NULL, NULL); + + scummcfg->set("BasePath", workdir, "wince"); + + for (i=0; iset(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 +#include +#include +#include +#include + +#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 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 +#include +#include +#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 + +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 + +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 + #define SHMENUBAR RCDATA + #if defined(WIN32_PLATFORM_PSPC) && (_WIN32_WCE >= 300) + #include + #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 + +#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 +#include +#include +#include +#include +#include +#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; iget("ActionTypes", "wince"); + if (current && version) { + for (i=0; iset("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; iset("ActionKeys", tempo, "wince"); + tempo[0] = '\0'; + work = getActionTypes(); + for (i=0; iset("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 Binary files /dev/null and b/backends/wince/pocketscumm.ico differ 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 +#include +#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<= 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; ipalVersion = 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= 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; + + +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<= 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)<>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)<>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)< 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< 0) + { + bitshift = 8-gxdp.cBPP; + bitmask = ((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 +#include + +#include +#include + +#include +#include +#include +#ifdef USE_XV_SCALING +#include +#include +#endif +#include + +#include +#include + +#include +#include +#include +#include + +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, ¶m) != 0) { + error("Error in the SNDCTL_DSP_SETFRAGMENT ioctl !\n"); + exit(1); + } + param = AFMT_S16_LE; + if (ioctl(sound_fd, SNDCTL_DSP_SETFMT, ¶m) == -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, ¶m) == -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, ¶m) == -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(¤t_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); +} -- cgit v1.2.3