2310b12

diff --git a/audio.cpp b/audio.cpp
index 411c685ac0c45d31d783f6e3d96c7da7b8912a8f..2fd3cf097e13b2f1982e653d57b6bdfbdf1ed909 100644 (file)
--- a/audio.cpp
+++ b/audio.cpp
@@ -236,7 +236,7 @@ void audio_sampleripper (int mode)
 static void do_samplerip (struct audio_channel_data *adp)
 {
        struct ripped_sample *rs = ripped_samples, *prev;
-       int len = adp->len * 2;
+       int len = adp->wlen * 2;
        uae_u8 *smp = chipmem_xlate_indirect (adp->pt);
        int cnt = 0, i;
 
@@ -1325,6 +1325,8 @@ static void audio_state_channel2 (int nr, bool perfin)
                if (cdp->wlen != 1)
                        cdp->wlen = (cdp->wlen - 1) & 0xffff;
                cdp->state = 5;
+               if (sampleripper_enabled)
+                       do_samplerip (cdp);
                break;
        case 5:
                cdp->evtime = MAX_EV;

diff --git a/bsdsocket.cpp b/bsdsocket.cpp
index e14062805c537068edc7ca346e640896edb54fb2..0cd1b36a7ed16a84e81e96cbbb90f856445a4f6c 100644 (file)
--- a/bsdsocket.cpp
+++ b/bsdsocket.cpp
@@ -93,13 +93,16 @@ uae_u32 addmem (uae_u32 * dst, const uae_char *src, int len)
 static uae_u32 gettask (TrapContext *context)
 {
        uae_u32 currtask, a1 = m68k_areg (regs, 1);
+       TCHAR *tskname;
 
        m68k_areg (regs, 1) = 0;
        currtask = CallLib (context, get_long (4), -0x126); /* FindTask */
 
        m68k_areg (regs, 1) = a1;
 
-       BSDTRACE ((L"[%s] ", get_real_address (get_long (currtask + 10))));
+       tskname = au((char*)get_real_address (get_long (currtask + 10)));
+       BSDTRACE ((L"[%s] ", au));
+       xfree (tskname);
        return currtask;
 }
 

diff --git a/cfgfile.cpp b/cfgfile.cpp
index 9297a0483b2f6ae22d9046200ef41c976e4c9190..77edad0a902fc0ba16b7a9a3b9c41a8db632d38d 100644 (file)
--- a/cfgfile.cpp
+++ b/cfgfile.cpp
@@ -805,6 +805,12 @@ void cfgfile_save_options (struct zfile *f, struct uae_prefs *p, int type)
                        );
 #endif
        }
+
+       cfgfile_dwrite (f, L"gfx_center_horizontal_position", L"%d", p->gfx_xcenter_pos);
+       cfgfile_dwrite (f, L"gfx_center_vertical_position", L"%d", p->gfx_ycenter_pos);
+       cfgfile_dwrite (f, L"gfx_center_horizontal_size", L"%d", p->gfx_xcenter_size);
+       cfgfile_dwrite (f, L"gfx_center_vertical_size", L"%d", p->gfx_ycenter_size);
+
 #endif
 
        cfgfile_write_bool (f, L"immediate_blits", p->immediate_blits);
@@ -3598,8 +3604,10 @@ void default_prefs (struct uae_prefs *p, int type)
        p->gfx_afullscreen = GFX_WINDOW;
        p->gfx_pfullscreen = GFX_WINDOW;
        p->gfx_xcenter = 0; p->gfx_ycenter = 0;
-       p->gfx_xcenter_pos = -1; p->gfx_ycenter_pos = -1;
-       p->gfx_xcenter_size = -1; p->gfx_ycenter_size = -1;
+       p->gfx_xcenter_pos = -1;
+       p->gfx_ycenter_pos = -1;
+       p->gfx_xcenter_size = -1;
+       p->gfx_ycenter_size = -1;
        p->gfx_max_horizontal = RES_HIRES;
        p->gfx_max_vertical = VRES_DOUBLE;
        p->color_mode = 2;

diff --git a/custom.cpp b/custom.cpp
index 95ae58caeeb3afa4806ec1e938a1d98ddbcf0d41..8adf8375793234afcf6890209db53dc229b415ee 100644 (file)
--- a/custom.cpp
+++ b/custom.cpp
@@ -3311,7 +3311,8 @@ static void DMACON (int hpos, uae_u16 v)
 static void MISC_handler (void)
 {
        static bool dorecheck;
-       int i, recheck;
+       bool recheck;
+       int i;
        evt mintime;
        evt ct = get_cycles ();
        static int recursive;
@@ -3322,17 +3323,17 @@ static void MISC_handler (void)
        }
        recursive++;
        eventtab[ev_misc].active = 0;
-       recheck = 1;
+       recheck = true;
        while (recheck) {
-               recheck = 0;
+               recheck = false;
                mintime = ~0L;
                for (i = 0; i < ev2_max; i++) {
                        if (eventtab2[i].active) {
                                if (eventtab2[i].evtime == ct) {
-                                       eventtab2[i].active = 0;
+                                       eventtab2[i].active = false;
                                        eventtab2[i].handler (eventtab2[i].data);
                                        if (dorecheck || eventtab2[i].active) {
-                                               recheck = 1;
+                                               recheck = true;
                                                dorecheck = false;
                                        }
                                } else {
@@ -3344,7 +3345,7 @@ static void MISC_handler (void)
                }
        }
        if (mintime != ~0L) {
-               eventtab[ev_misc].active = 1;
+               eventtab[ev_misc].active = true;
                eventtab[ev_misc].oldcycles = ct;
                eventtab[ev_misc].evtime = ct + mintime;
                events_schedule ();
@@ -3377,7 +3378,7 @@ STATIC_INLINE void event2_newevent_xx (int no, evt t, uae_u32 data, evfunc2 func
                }
                next = no;
        }
-       eventtab2[no].active = 1;
+       eventtab2[no].active = true;
        eventtab2[no].evtime = et;
        eventtab2[no].handler = func;
        eventtab2[no].data = data;
@@ -3494,6 +3495,13 @@ static void INTENA (uae_u16 v)
 #endif
 }
 
+void INTREQ_nodelay (uae_u16 v)
+{
+       setclr (&intreq, v);
+       setclr (&intreq_internal, v);
+       doint ();
+}
+
 void INTREQ_f (uae_u16 v)
 {
        if (use_eventmode (v)) {
@@ -3550,10 +3558,10 @@ static void ADKCON (int hpos, uae_u16 v)
 {
        if (currprefs.produce_sound > 0)
                update_audio ();
+       DISK_update (hpos);
        DISK_update_adkcon (hpos, v);
        setclr (&adkcon, v);
        audio_update_adkmasks ();
-       DISK_update (hpos);
        if ((v >> 11) & 1)
                serial_uartbreak ((adkcon >> 11) & 1);
 }
@@ -5694,7 +5702,7 @@ static void hsync_handler_post (bool isvsync)
                if (vpos > last_planes_vpos)
                        last_planes_vpos = vpos;
                if (vpos >= minfirstline && first_planes_vpos == 0) {
-                       first_planes_vpos = vpos;
+                       first_planes_vpos = vpos > minfirstline ? vpos - 1 : vpos;
                } else if (vpos == current_maxvpos () - 1) {
                        last_planes_vpos = vpos - 1;
                }
@@ -6159,34 +6167,33 @@ STATIC_INLINE uae_u32 REGPARAM2 custom_wget_1 (int hpos, uaecptr addr, int noput
                if (!noput) {
                        int r;
                        uae_u16 old = last_custom_value1;
-                       uae_u16 l = currprefs.cpu_compatible && currprefs.cpu_model == 68000 ? regs.irc : 0xffff;//last_custom_value;
+                       uae_u16 l = currprefs.cpu_compatible && currprefs.cpu_model == 68000 ? regs.irc : 0xffff;
                        decide_line (hpos);
                        decide_fetch (hpos);
                        decide_blitter (hpos);
                        debug_wputpeek (0xdff000 + addr, l);
                        r = custom_wput_1 (hpos, addr, l, 1);
-                       if (currprefs.chipset_mask & CSMASK_AGA) {
-                               v = l;
-                               last_custom_value1 = 0xffff;
-                       } else if (currprefs.chipset_mask & CSMASK_ECS_AGNUS) {
-                               v = old;
-                       } else {
-                               if ((addr & 0x1fe) == 0) {
-                                       if (is_cycle_ce ())
-                                               v = old;
-                                       else
-                                               v = l;
+                       if (r) { // register don't exist
+                               if (currprefs.chipset_mask & CSMASK_ECS_AGNUS) {
+                                       v = l;
                                } else {
-                                       v = old;
+                                       if ((addr & 0x1fe) == 0) {
+                                               if (is_cycle_ce ())
+                                                       v = last_custom_value1;
+                                               else
+                                                       v = l;
+                                       }
                                }
+                       } else {
+                               v = 0xffff;
                        }
 #if CUSTOM_DEBUG > 0
                        write_log (L"%08X read = %04X. Value written=%04X PC=%08x\n", 0xdff000 | addr, v, l, M68K_GETPC);
 #endif
-
+                       return v;
                }
-               return v;
        }
+       last_custom_value1 = v;
        return v;
 }
 
@@ -6241,6 +6248,8 @@ static uae_u32 REGPARAM2 custom_lget (uaecptr addr)
 }
 static int REGPARAM2 custom_wput_1 (int hpos, uaecptr addr, uae_u32 value, int noget)
 {
+       if (!noget)
+               last_custom_value1 = value;
        addr &= 0x1FE;
        value &= 0xffff;
 #ifdef ACTION_REPLAY

diff --git a/debug.cpp b/debug.cpp
index 2355f37a805336c73d4bff3a85689bcd3435ebf9..17b65e733e5252435b596645862e97b0586dfa16 100644 (file)
--- a/debug.cpp
+++ b/debug.cpp
@@ -1784,18 +1784,21 @@ static int memwatch_func (uaecptr addr, int rwi, int size, uae_u32 *valp)
                if (!m->frozen && m->val_enabled) {
                        int trigger = 0;
                        uae_u32 mask = (1 << (m->size * 8)) - 1;
+                       uae_u32 mval = m->val;
                        int scnt = size;
                        for (;;) {
-                               if (((m->val & mask) & m->val_mask) == ((val & mask) & m->val_mask))
+                               if (((mval & mask) & m->val_mask) == ((val & mask) & m->val_mask))
                                        trigger = 1;
                                if (mask & 0x80000000)
                                        break;
                                if (m->size == 1) {
                                        mask <<= 8;
+                                       mval <<= 8;
                                        scnt--;
                                } else if (m->size == 2) {
                                        mask <<= 16;
                                        scnt -= 2;
+                                       mval <<= 16;
                                }
                                if (scnt <= 0)
                                        break;

diff --git a/disk2.cpp b/disk2.cpp
new file mode 100644 (file)
index 0000000..488c74d
--- /dev/null
+++ b/disk2.cpp
@@ -0,0 +1,3934 @@
+/*
+* UAE - The Un*x Amiga Emulator
+*
+* Floppy disk emulation
+*
+* Copyright 1995 Hannu Rummukainen
+* Copyright 1995-2001 Bernd Schmidt
+* Copyright 2000-2003 Toni Wilen
+*
+* Original High Density Drive Handling by Dr. Adil Temel (C) 2001 [atemel1@hotmail.com]
+*
+*/
+
+#include "sysconfig.h"
+#include "sysdeps.h"
+
+int disk_debug_logging = 0;
+int disk_debug_mode = 0;
+int disk_debug_track = -1;
+
+#include "uae.h"
+#include "options.h"
+#include "memory.h"
+#include "events.h"
+#include "custom.h"
+#include "ersatz.h"
+#include "disk.h"
+#include "gui.h"
+#include "zfile.h"
+#include "newcpu.h"
+#include "osemu.h"
+#include "execlib.h"
+#include "savestate.h"
+#include "cia.h"
+#include "debug.h"
+#ifdef FDI2RAW
+#include "fdi2raw.h"
+#endif
+#include "catweasel.h"
+#include "driveclick.h"
+#ifdef CAPS
+#include "caps/caps_win32.h"
+#endif
+#include "crc32.h"
+#include "inputrecord.h"
+#include "amax.h"
+#ifdef RETROPLATFORM
+#include "rp.h"
+#endif
+
+#undef CATWEASEL
+
+static int longwritemode = 0;
+
+/* support HD floppies */
+#define FLOPPY_DRIVE_HD
+/* writable track length with normal 2us bitcell/300RPM motor, 12667 PAL, 12797 NTSC */
+#define FLOPPY_WRITE_LEN (currprefs.floppy_write_length > 256 ? currprefs.floppy_write_length / 2 : (currprefs.ntscmode ? (12798 / 2) : (12668 / 2)))
+#define FLOPPY_WRITE_MAXLEN 0x3800
+/* This works out to 350 */
+#define FLOPPY_GAP_LEN (FLOPPY_WRITE_LEN - 11 * 544)
+/* (cycles/bitcell) << 8, normal = ((2us/280ns)<<8) = ~1829.5714 */
+#define NORMAL_FLOPPY_SPEED (currprefs.ntscmode ? 1811 : 1829)
+/* max supported floppy drives, for small memory systems */
+#define MAX_FLOPPY_DRIVES 4
+
+#ifdef FLOPPY_DRIVE_HD
+#define DDHDMULT 2
+#else
+#define DDHDMULT 1
+#endif
+#define MAX_SECTORS (DDHDMULT * 11)
+
+#undef DEBUG_DRIVE_ID
+
+/* UAE-1ADF (ADF_EXT2)
+* W reserved
+* W number of tracks (default 2*80=160)
+*
+* W reserved
+* W type, 0=normal AmigaDOS track, 1 = raw MFM (upper byte = disk revolutions - 1)
+* L available space for track in bytes (must be even)
+* L track length in bits
+*/
+
+static int side, direction;
+static uae_u8 selected = 15, disabled;
+
+static uae_u8 writebuffer[544 * MAX_SECTORS];
+
+#define DISK_INDEXSYNC 1
+#define DISK_WORDSYNC 2
+#define DISK_REVOLUTION 4 /* 8,16,32,64 */
+
+#define DSKREADY_UP_TIME 20
+#define DSKREADY_DOWN_TIME 50
+
+static int dskdmaen, dsklength, dsklength2, dsklen;
+static uae_u16 dskbytr_val;
+static uae_u32 dskpt;
+static bool fifo_filled;
+static uae_u16 fifo[3];
+static int fifo_inuse[3];
+static int dma_enable, bitoffset, syncoffset;
+static uae_u16 word, dsksync;
+static unsigned long dsksync_cycles;
+#define WORDSYNC_TIME 11
+/* Always carried through to the next line.  */
+static int disk_hpos;
+static int disk_jitter;
+
+static uae_u8 prev_data;
+static int prev_step;
+
+typedef enum { TRACK_AMIGADOS, TRACK_RAW, TRACK_RAW1, TRACK_PCDOS, TRACK_DISKSPARE, TRACK_NONE } image_tracktype;
+typedef struct {
+       uae_u16 len;
+       uae_u32 offs;
+       int bitlen, track;
+       uae_u16 sync;
+       image_tracktype type;
+       int revolutions;
+} trackid;
+
+#define MAX_TRACKS (2 * 83)
+
+/* We have three kinds of Amiga floppy drives
+* - internal A500/A2000 drive:
+*   ID is always DRIVE_ID_NONE (S.T.A.G expects this)
+* - HD drive (A3000/A4000):
+*   ID is DRIVE_ID_35DD if DD floppy is inserted or drive is empty
+*   ID is DRIVE_ID_35HD if HD floppy is inserted
+* - regular external drive:
+*   ID is always DRIVE_ID_35DD
+*/
+
+#define DRIVE_ID_NONE  0x00000000
+#define DRIVE_ID_35DD  0xFFFFFFFF
+#define DRIVE_ID_35HD  0xAAAAAAAA
+#define DRIVE_ID_525SD 0x55555555 /* 40 track 5.25 drive , kickstart does not recognize this */
+
+typedef enum { ADF_NONE = -1, ADF_NORMAL, ADF_EXT1, ADF_EXT2, ADF_FDI, ADF_IPF, ADF_CATWEASEL, ADF_PCDOS } drive_filetype;
+typedef struct {
+       struct zfile *diskfile;
+       struct zfile *writediskfile;
+       drive_filetype filetype;
+       trackid trackdata[MAX_TRACKS];
+       trackid writetrackdata[MAX_TRACKS];
+       int buffered_cyl, buffered_side;
+       int cyl;
+       bool motoroff;
+       int motordelay; /* dskrdy needs some clock cycles before it changes after switching off motor */
+       bool state;
+       bool wrprot;
+       uae_u16 bigmfmbuf[0x4000 * DDHDMULT];
+       uae_u16 tracktiming[0x4000 * DDHDMULT];
+       int multi_revolution;
+       int skipoffset;
+       int mfmpos;
+       int indexoffset;
+       int tracklen;
+       int revolutions;
+       int prevtracklen;
+       int trackspeed;
+       int num_tracks, write_num_tracks, num_secs;
+       int hard_num_cyls;
+       bool dskchange;
+       int dskchange_time;
+       bool dskready;
+       int dskready_up_time;
+       int dskready_down_time;
+       int writtento;
+       int steplimit;
+       frame_time_t steplimitcycle;
+       int indexhack, indexhackmode;
+       int ddhd; /* 1=DD 2=HD */
+       int drive_id_scnt; /* drive id shift counter */
+       int idbit;
+       unsigned long drive_id; /* drive id to be reported */
+       TCHAR newname[256]; /* storage space for new filename during eject delay */
+       uae_u32 crc32;
+#ifdef FDI2RAW
+       FDI *fdi;
+#endif
+       int useturbo;
+       int floppybitcounter; /* number of bits left */
+#ifdef CATWEASEL
+       catweasel_drive *catweasel;
+#else
+       int catweasel;
+       int amax;
+#endif
+} drive;
+
+#define MIN_STEPLIMIT_CYCLE (CYCLE_UNIT * 250)
+
+static uae_u16 bigmfmbufw[0x4000 * DDHDMULT];
+static drive floppy[MAX_FLOPPY_DRIVES];
+static TCHAR dfxhistory[2][MAX_PREVIOUS_FLOPPIES][MAX_DPATH];
+
+static uae_u8 exeheader[]={0x00,0x00,0x03,0xf3,0x00,0x00,0x00,0x00};
+static uae_u8 bootblock_ofs[]={
+       0x44,0x4f,0x53,0x00,0xc0,0x20,0x0f,0x19,0x00,0x00,0x03,0x70,0x43,0xfa,0x00,0x18,
+       0x4e,0xae,0xff,0xa0,0x4a,0x80,0x67,0x0a,0x20,0x40,0x20,0x68,0x00,0x16,0x70,0x00,
+       0x4e,0x75,0x70,0xff,0x60,0xfa,0x64,0x6f,0x73,0x2e,0x6c,0x69,0x62,0x72,0x61,0x72,
+       0x79
+};
+static uae_u8 bootblock_ffs[]={
+       0x44, 0x4F, 0x53, 0x01, 0xE3, 0x3D, 0x0E, 0x72, 0x00, 0x00, 0x03, 0x70, 0x43, 0xFA, 0x00, 0x3E,
+       0x70, 0x25, 0x4E, 0xAE, 0xFD, 0xD8, 0x4A, 0x80, 0x67, 0x0C, 0x22, 0x40, 0x08, 0xE9, 0x00, 0x06,
+       0x00, 0x22, 0x4E, 0xAE, 0xFE, 0x62, 0x43, 0xFA, 0x00, 0x18, 0x4E, 0xAE, 0xFF, 0xA0, 0x4A, 0x80,
+       0x67, 0x0A, 0x20, 0x40, 0x20, 0x68, 0x00, 0x16, 0x70, 0x00, 0x4E, 0x75, 0x70, 0xFF, 0x4E, 0x75,
+       0x64, 0x6F, 0x73, 0x2E, 0x6C, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x00, 0x65, 0x78, 0x70, 0x61,
+       0x6E, 0x73, 0x69, 0x6F, 0x6E, 0x2E, 0x6C, 0x69, 0x62, 0x72, 0x61, 0x72, 0x79, 0x00, 0x00, 0x00,
+};
+
+#define FS_OFS_DATABLOCKSIZE 488
+#define FS_FLOPPY_BLOCKSIZE 512
+#define FS_EXTENSION_BLOCKS 72
+#define FS_FLOPPY_TOTALBLOCKS 1760
+#define FS_FLOPPY_RESERVED 2
+
+static void writeimageblock (struct zfile *dst, uae_u8 *sector, int offset)
+{
+       zfile_fseek (dst, offset, SEEK_SET);
+       zfile_fwrite (sector, FS_FLOPPY_BLOCKSIZE, 1, dst);
+}
+
+static void disk_checksum (uae_u8 *p, uae_u8 *c)
+{
+       uae_u32 cs = 0;
+       int i;
+       for (i = 0; i < FS_FLOPPY_BLOCKSIZE; i+= 4)
+               cs += (p[i] << 24) | (p[i+1] << 16) | (p[i+2] << 8) | (p[i+3] << 0);
+       cs = -cs;
+       c[0] = cs >> 24; c[1] = cs >> 16; c[2] = cs >> 8; c[3] = cs >> 0;
+}
+
+static int dirhash (const uae_char *name)
+{
+       unsigned long hash;
+       int i;
+
+       hash = strlen (name);
+       for(i = 0; i < strlen (name); i++) {
+               hash = hash * 13;
+               hash = hash + toupper (name[i]);
+               hash = hash & 0x7ff;
+       }
+       hash = hash % ((FS_FLOPPY_BLOCKSIZE / 4) - 56);
+       return hash;
+}
+
+static void disk_date (uae_u8 *p)
+{
+       time_t t;
+       struct tm *today;
+       int year, days, minutes, ticks;
+       TCHAR tmp[10];
+
+       time (&t);
+       today = localtime( &t );
+       _tcsftime (tmp, sizeof tmp / sizeof (TCHAR), L"%Y", today);
+       year = _tstoi (tmp);
+       _tcsftime (tmp, sizeof tmp / sizeof (TCHAR), L"%j", today);
+       days = _tstoi (tmp) - 1;
+       _tcsftime (tmp, sizeof tmp / sizeof (TCHAR), L"%H", today);
+       minutes = _tstoi (tmp) * 60;
+       _tcsftime (tmp, sizeof tmp / sizeof (TCHAR), L"%M", today);
+       minutes += _tstoi (tmp);
+       _tcsftime (tmp, sizeof tmp / sizeof (TCHAR), L"%S", today);
+       ticks = _tstoi (tmp) * 50;
+       while (year > 1978) {
+               if ( !(year % 100) ? !(year % 400) : !(year % 4) ) days++;
+               days += 365;
+               year--;
+       }
+       p[0] = days >> 24; p[1] = days >> 16; p[2] = days >> 8; p[3] = days >> 0;
+       p[4] = minutes >> 24; p[5] = minutes >> 16; p[6] = minutes >> 8; p[7] = minutes >> 0;
+       p[8] = ticks >> 24; p[9] = ticks >> 16; p[10] = ticks >> 8; p[11] = ticks >> 0;
+}
+
+static void createbootblock (uae_u8 *sector, int bootable)
+{
+       memset (sector, 0, FS_FLOPPY_BLOCKSIZE);
+       memcpy (sector, "DOS", 3);
+       if (bootable)
+               memcpy (sector, bootblock_ofs, sizeof bootblock_ofs);
+}
+
+static void createrootblock (uae_u8 *sector, char *disk_name)
+{
+       memset (sector, 0, FS_FLOPPY_BLOCKSIZE);
+       sector[0+3] = 2;
+       sector[12+3] = 0x48;
+       sector[312] = sector[313] = sector[314] = sector[315] = (uae_u8)0xff;
+       sector[316+2] = 881 >> 8; sector[316+3] = 881 & 255;
+       sector[432] = strlen (disk_name);
+       strcpy ((char*)sector + 433, disk_name);
+       sector[508 + 3] = 1;
+       disk_date (sector + 420);
+       memcpy (sector + 472, sector + 420, 3 * 4);
+       memcpy (sector + 484, sector + 420, 3 * 4);
+}
+
+static int getblock (uae_u8 *bitmap)
+{
+       int i = 0;
+       while (bitmap[i] != 0xff) {
+               if (bitmap[i] == 0) {
+                       bitmap[i] = 1;
+                       return i;
+               }
+               i++;
+       }
+       return -1;
+}
+
+static void pl (uae_u8 *sector, int offset, uae_u32 v)
+{
+       sector[offset + 0] = v >> 24;
+       sector[offset + 1] = v >> 16;
+       sector[offset + 2] = v >> 8;
+       sector[offset + 3] = v >> 0;
+}
+
+static int createdirheaderblock (uae_u8 *sector, int parent, const char *filename, uae_u8 *bitmap)
+{
+       int block = getblock (bitmap);
+
+       memset (sector, 0, FS_FLOPPY_BLOCKSIZE);
+       pl (sector, 0, 2);
+       pl (sector, 4, block);
+       disk_date (sector + 512 - 92);
+       sector[512 - 80] = strlen (filename);
+       strcpy ((char*)sector + 512 - 79, filename);
+       pl (sector, 512 - 12, parent);
+       pl (sector, 512 - 4, 2);
+       return block;
+}
+
+static int createfileheaderblock (struct zfile *z,uae_u8 *sector, int parent, const char *filename, struct zfile *src, uae_u8 *bitmap)
+{
+       uae_u8 sector2[FS_FLOPPY_BLOCKSIZE];
+       uae_u8 sector3[FS_FLOPPY_BLOCKSIZE];
+       int block = getblock (bitmap);
+       int datablock = getblock (bitmap);
+       int datasec = 1;
+       int extensions;
+       int extensionblock, extensioncounter, headerextension = 1;
+       int size;
+
+       zfile_fseek (src, 0, SEEK_END);
+       size = zfile_ftell (src);
+       zfile_fseek (src, 0, SEEK_SET);
+       extensions = (size + FS_OFS_DATABLOCKSIZE - 1) / FS_OFS_DATABLOCKSIZE;
+
+       memset (sector, 0, FS_FLOPPY_BLOCKSIZE);
+       pl (sector, 0, 2);
+       pl (sector, 4, block);
+       pl (sector, 8, extensions > FS_EXTENSION_BLOCKS ? FS_EXTENSION_BLOCKS : extensions);
+       pl (sector, 16, datablock);
+       pl (sector, FS_FLOPPY_BLOCKSIZE - 188, size);
+       disk_date (sector + FS_FLOPPY_BLOCKSIZE - 92);
+       sector[FS_FLOPPY_BLOCKSIZE - 80] = strlen (filename);
+       strcpy ((char*)sector + FS_FLOPPY_BLOCKSIZE - 79, filename);
+       pl (sector, FS_FLOPPY_BLOCKSIZE - 12, parent);
+       pl (sector, FS_FLOPPY_BLOCKSIZE - 4, -3);
+       extensioncounter = 0;
+       extensionblock = 0;
+
+       while (size > 0) {
+               int datablock2 = datablock;
+               int extensionblock2 = extensionblock;
+               if (extensioncounter == FS_EXTENSION_BLOCKS) {
+                       extensioncounter = 0;
+                       extensionblock = getblock (bitmap);
+                       if (datasec > FS_EXTENSION_BLOCKS + 1) {
+                               pl (sector3, 8, FS_EXTENSION_BLOCKS);
+                               pl (sector3, FS_FLOPPY_BLOCKSIZE - 8, extensionblock);
+                               pl (sector3, 4, extensionblock2);
+                               disk_checksum(sector3, sector3 + 20);
+                               writeimageblock (z, sector3, extensionblock2 * FS_FLOPPY_BLOCKSIZE);
+                       } else {
+                               pl (sector, 512 - 8, extensionblock);
+                       }
+                       memset (sector3, 0, FS_FLOPPY_BLOCKSIZE);
+                       pl (sector3, 0, 16);
+                       pl (sector3, FS_FLOPPY_BLOCKSIZE - 12, block);
+                       pl (sector3, FS_FLOPPY_BLOCKSIZE - 4, -3);
+               }
+               memset (sector2, 0, FS_FLOPPY_BLOCKSIZE);
+               pl (sector2, 0, 8);
+               pl (sector2, 4, block);
+               pl (sector2, 8, datasec++);
+               pl (sector2, 12, size > FS_OFS_DATABLOCKSIZE ? FS_OFS_DATABLOCKSIZE : size);
+               zfile_fread (sector2 + 24, size > FS_OFS_DATABLOCKSIZE ? FS_OFS_DATABLOCKSIZE : size, 1, src);
+               size -= FS_OFS_DATABLOCKSIZE;
+               datablock = 0;
+               if (size > 0) datablock = getblock (bitmap);
+               pl (sector2, 16, datablock);
+               disk_checksum(sector2, sector2 + 20);
+               writeimageblock (z, sector2, datablock2 * FS_FLOPPY_BLOCKSIZE);
+               if (datasec <= FS_EXTENSION_BLOCKS + 1)
+                       pl (sector, 512 - 204 - extensioncounter * 4, datablock2);
+               else
+                       pl (sector3, 512 - 204 - extensioncounter * 4, datablock2);
+               extensioncounter++;
+       }
+       if (datasec > FS_EXTENSION_BLOCKS) {
+               pl (sector3, 8, extensioncounter);
+               disk_checksum(sector3, sector3 + 20);
+               writeimageblock (z, sector3, extensionblock * FS_FLOPPY_BLOCKSIZE);
+       }
+       disk_checksum(sector, sector + 20);
+       writeimageblock (z, sector, block * FS_FLOPPY_BLOCKSIZE);
+       return block;
+}
+
+static void createbitmapblock (uae_u8 *sector, uae_u8 *bitmap)
+{
+       uae_u8 mask;
+       int i, j;
+       memset (sector, 0, FS_FLOPPY_BLOCKSIZE);
+       for (i = FS_FLOPPY_RESERVED; i < FS_FLOPPY_TOTALBLOCKS; i += 8) {
+               mask = 0;
+               for (j = 0; j < 8; j++) {
+                       if (bitmap[i + j]) mask |= 1 << j;
+               }
+               sector[4 + i / 8] = mask;
+       }
+       disk_checksum(sector, sector + 0);
+}
+
+static int createimagefromexe (struct zfile *src, struct zfile *dst)
+{
+       uae_u8 sector1[FS_FLOPPY_BLOCKSIZE], sector2[FS_FLOPPY_BLOCKSIZE];
+       uae_u8 bitmap[FS_FLOPPY_TOTALBLOCKS + 8];
+       int exesize;
+       int blocksize = FS_OFS_DATABLOCKSIZE;
+       int blocks, extensionblocks;
+       int totalblocks;
+       int fblock1, dblock1;
+       char *fname1 = "runme.exe";
+       TCHAR *fname1b = L"runme.adf";
+       char *fname2 = "startup-sequence";
+       char *dirname1 = "s";
+       struct zfile *ss;
+
+       memset (bitmap, 0, sizeof bitmap);
+       zfile_fseek (src, 0, SEEK_END);
+       exesize = zfile_ftell (src);
+       blocks = (exesize + blocksize - 1) / blocksize;
+       extensionblocks = (blocks + FS_EXTENSION_BLOCKS - 1) / FS_EXTENSION_BLOCKS;
+       /* bootblock=2, root=1, bitmap=1, startup-sequence=1+1, exefileheader=1 */
+       totalblocks = 2 + 1 + 1 + 2 + 1 + blocks + extensionblocks;
+       if (totalblocks > FS_FLOPPY_TOTALBLOCKS)
+               return 0;
+
+       bitmap[880] = 1;
+       bitmap[881] = 1;
+       bitmap[0] = 1;
+       bitmap[1] = 1;
+
+       dblock1 = createdirheaderblock (sector2, 880, dirname1, bitmap);
+       ss = zfile_fopen_empty (src, fname1b, strlen (fname1));
+       zfile_fwrite (fname1, strlen(fname1), 1, ss);
+       fblock1 = createfileheaderblock (dst, sector1,  dblock1, fname2, ss, bitmap);
+       zfile_fclose (ss);
+       pl (sector2, 24 + dirhash (fname2) * 4, fblock1);
+       disk_checksum(sector2, sector2 + 20);
+       writeimageblock (dst, sector2, dblock1 * FS_FLOPPY_BLOCKSIZE);
+
+       fblock1 = createfileheaderblock (dst, sector1, 880, fname1, src, bitmap);
+
+       createrootblock (sector1, "empty");
+       pl (sector1, 24 + dirhash (fname1) * 4, fblock1);
+       pl (sector1, 24 + dirhash (dirname1) * 4, dblock1);
+       disk_checksum(sector1, sector1 + 20);
+       writeimageblock (dst, sector1, 880 * FS_FLOPPY_BLOCKSIZE);
+
+       createbitmapblock (sector1, bitmap);
+       writeimageblock (dst, sector1, 881 * FS_FLOPPY_BLOCKSIZE);
+
+       createbootblock (sector1, 1);
+       writeimageblock (dst, sector1, 0 * FS_FLOPPY_BLOCKSIZE);
+
+       return 1;
+}
+
+static int get_floppy_speed (void)
+{
+       int m = currprefs.floppy_speed;
+       if (m <= 10)
+               m = 100;
+       m = NORMAL_FLOPPY_SPEED * 100 / m;
+       return m;
+}
+
+static int get_floppy_speed2 (drive *drv)
+{
+       int m = get_floppy_speed () * drv->tracklen / (2 * 8 * FLOPPY_WRITE_LEN * drv->ddhd);
+       if (m <= 0)
+               m = 1;
+       return m;
+}
+
+static TCHAR *drive_id_name(drive *drv)
+{
+       switch(drv->drive_id)
+       {
+       case DRIVE_ID_35HD : return L"3.5HD";
+       case DRIVE_ID_525SD: return L"5.25SD";
+       case DRIVE_ID_35DD : return L"3.5DD";
+       case DRIVE_ID_NONE : return L"NONE";
+       }
+       return L"UNKNOWN";
+}
+
+/* Simulate exact behaviour of an A3000T 3.5 HD disk drive.
+* The drive reports to be a 3.5 DD drive whenever there is no
+* disk or a 3.5 DD disk is inserted. Only 3.5 HD drive id is reported
+* when a real 3.5 HD disk is inserted. -Adil
+*/
+static void drive_settype_id (drive *drv)
+{
+       int t = currprefs.floppyslots[drv - &floppy[0]].dfxtype;
+
+       switch (t)
+       {
+       case DRV_35_HD:
+#ifdef FLOPPY_DRIVE_HD
+               if (!drv->diskfile || drv->ddhd <= 1)
+                       drv->drive_id = DRIVE_ID_35DD;
+               else
+                       drv->drive_id = DRIVE_ID_35HD;
+#else
+               drv->drive_id = DRIVE_ID_35DD;
+#endif
+               break;
+       case DRV_35_DD_ESCOM:
+       case DRV_35_DD:
+       default:
+               drv->drive_id = DRIVE_ID_35DD;
+               break;
+       case DRV_525_SD:
+               drv->drive_id = DRIVE_ID_525SD;
+               break;
+       case DRV_NONE:
+               drv->drive_id = DRIVE_ID_NONE;
+               break;
+       }
+#ifdef DEBUG_DRIVE_ID
+       write_log (L"drive_settype_id: DF%d: set to %s\n", drv-floppy, drive_id_name(drv));
+#endif
+}
+
+static void drive_image_free (drive *drv)
+{
+       switch (drv->filetype)
+       {
+       case ADF_IPF:
+#ifdef CAPS
+               caps_unloadimage (drv - floppy);
+#endif
+               break;
+       case ADF_FDI:
+#ifdef FDI2RAW
+               fdi2raw_header_free (drv->fdi);
+               drv->fdi = 0;
+#endif
+               break;
+       }
+       drv->filetype = ADF_NONE;
+       zfile_fclose (drv->diskfile);
+       drv->diskfile = 0;
+       zfile_fclose (drv->writediskfile);
+       drv->writediskfile = 0;
+}
+
+static int drive_insert (drive * drv, struct uae_prefs *p, int dnum, const TCHAR *fname, bool fake);
+
+static void reset_drive_gui (int num)
+{
+       gui_data.drive_disabled[num] = 0;
+       gui_data.df[num][0] = 0;
+       gui_data.crc32[num] = 0;
+       if (currprefs.floppyslots[num].dfxtype < 0)
+               gui_data.drive_disabled[num] = 1;
+}
+
+static void setamax (void)
+{
+#ifdef AMAX
+       if (currprefs.amaxromfile[0]) {
+               /* Put A-Max as last drive in drive chain */
+               int j;
+               for (j = 0; j < MAX_FLOPPY_DRIVES; j++)
+                       if (floppy[j].amax)
+                               return;
+               for (j = 0; j < MAX_FLOPPY_DRIVES; j++) {
+                       if ((1 << j) & disabled) {
+                               floppy[j].amax = 1;
+                               write_log (L"AMAX: drive %d\n", j);
+                               return;
+                       }
+               }
+       }
+#endif
+}
+
+static void reset_drive (int num)
+{
+       drive *drv = &floppy[num];
+
+       drv->amax = 0;
+       drive_image_free (drv);
+       drv->motoroff = 1;
+       drv->idbit = 0;
+       drv->drive_id = 0;
+       drv->drive_id_scnt = 0;
+       disabled &= ~(1 << num);
+       if (currprefs.floppyslots[num].dfxtype < 0)
+               disabled |= 1 << num;
+       reset_drive_gui (num);
+       /* most internal Amiga floppy drives won't enable
+       * diskready until motor is running at full speed
+       * and next indexsync has been passed
+       */
+       drv->indexhackmode = 0;
+       if (num == 0 && currprefs.floppyslots[num].dfxtype == 0)
+               drv->indexhackmode = 1;
+       drv->dskchange_time = 0;
+       drv->dskchange = 0;
+       drv->dskready_down_time = 0;
+       drv->dskready_up_time = 0;
+       drv->buffered_cyl = -1;
+       drv->buffered_side = -1;
+       gui_led (num + LED_DF0, 0);
+       drive_settype_id (drv);
+       _tcscpy (currprefs.floppyslots[num].df, changed_prefs.floppyslots[num].df);
+       drv->newname[0] = 0;
+       if (!drive_insert (drv, &currprefs, num, currprefs.floppyslots[num].df, false))
+               disk_eject (num);
+}
+
+/* code for track display */
+static void update_drive_gui (int num)
+{
+       drive *drv = floppy + num;
+       bool writ = dskdmaen == 3 && drv->state && !((selected | disabled) & (1 << num));
+
+       if (drv->state == gui_data.drive_motor[num]
+               && drv->cyl == gui_data.drive_track[num]
+               && side == gui_data.drive_side
+               && drv->crc32 == gui_data.crc32[num]
+               && writ == gui_data.drive_writing[num]
+               && !_tcscmp (gui_data.df[num], currprefs.floppyslots[num].df))
+               return;
+       _tcscpy (gui_data.df[num], currprefs.floppyslots[num].df);
+       gui_data.crc32[num] = drv->crc32;
+       gui_data.drive_motor[num] = drv->state;
+       gui_data.drive_track[num] = drv->cyl;
+       gui_data.drive_side = side;
+       gui_data.drive_writing[num] = writ;
+       gui_led (num + LED_DF0, (gui_data.drive_motor[num] ? 1 : 0) | (gui_data.drive_writing[num] ? 2 : 0));
+}
+
+static void drive_fill_bigbuf (drive * drv,int);
+
+int DISK_validate_filename (const TCHAR *fname, int leave_open, bool *wrprot, uae_u32 *crc32, struct zfile **zf)
+{
+       if (zf)
+               *zf = NULL;
+       if (crc32)
+               *crc32 = 0;
+       if (leave_open || !zf) {
+               struct zfile *f = zfile_fopen (fname, L"r+b", ZFD_NORMAL | ZFD_DISKHISTORY);
+               if (f) {
+                       if (wrprot)
+                               *wrprot = 0;
+               } else {
+                       if (wrprot)
+                               *wrprot = 1;
+                       f = zfile_fopen (fname, L"rb", ZFD_NORMAL | ZFD_DISKHISTORY);
+               }
+               if (f && crc32)
+                       *crc32 = zfile_crc32 (f);
+               if (!zf)
+                       zfile_fclose (f);
+               else
+                       *zf = f;
+               return f ? 1 : 0;
+       } else {
+               if (zfile_exists (fname)) {
+                       if (wrprot)
+                               *wrprot = 0;
+                       if (crc32) {
+                               struct zfile *f = zfile_fopen (fname, L"rb", ZFD_NORMAL | ZFD_DISKHISTORY);
+                               if (f)
+                                       *crc32 = zfile_crc32 (f);
+                               zfile_fclose (f);
+                       }
+                       return 1;
+               } else {
+                       if (wrprot)
+                               *wrprot = 1;
+                       return 0;
+               }
+       }
+}
+
+static void updatemfmpos (drive *drv)
+{
+       if (drv->prevtracklen)
+               drv->mfmpos = drv->mfmpos * (drv->tracklen * 1000 / drv->prevtracklen) / 1000;
+       drv->mfmpos %= drv->tracklen;
+       drv->prevtracklen = drv->tracklen;
+}
+
+static void track_reset (drive *drv)
+{
+       drv->tracklen = FLOPPY_WRITE_LEN * drv->ddhd * 2 * 8;
+       drv->revolutions = 1;
+       drv->trackspeed = get_floppy_speed ();
+       drv->buffered_side = -1;
+       drv->skipoffset = -1;
+       drv->tracktiming[0] = 0;
+       memset (drv->bigmfmbuf, 0xaa, FLOPPY_WRITE_LEN * 2 * drv->ddhd);
+       updatemfmpos (drv);
+}
+
+static int read_header_ext2 (struct zfile *diskfile, trackid *trackdata, int *num_tracks, int *ddhd)
+{
+       uae_u8 buffer[2 + 2 + 4 + 4];
+       trackid *tid;
+       int offs;
+       int i;
+
+       zfile_fseek (diskfile, 0, SEEK_SET);
+       zfile_fread (buffer, 1, 8, diskfile);
+       if (strncmp ((char*)buffer, "UAE-1ADF", 8))
+               return 0;
+       zfile_fread (buffer, 1, 4, diskfile);
+       *num_tracks = buffer[2] * 256 + buffer[3];
+       offs = 8 + 2 + 2 + (*num_tracks) * (2 + 2 + 4 + 4);
+
+       for (i = 0; i < (*num_tracks); i++) {
+               tid = trackdata + i;
+               zfile_fread (buffer, 2 + 2 + 4 + 4, 1, diskfile);
+               tid->type = (image_tracktype)buffer[3];
+               tid->revolutions = buffer[2] + 1;
+               tid->len = buffer[5] * 65536 + buffer[6] * 256 + buffer[7];
+               tid->bitlen = buffer[9] * 65536 + buffer[10] * 256 + buffer[11];
+               tid->offs = offs;
+               if (tid->len > 20000 && ddhd)
+                       *ddhd = 2;
+               tid->track = i;
+               offs += tid->len;
+       }
+       return 1;
+}
+
+TCHAR *DISK_get_saveimagepath (const TCHAR *name)
+{
+       static TCHAR name1[MAX_DPATH];
+       TCHAR name2[MAX_DPATH];
+       TCHAR path[MAX_DPATH];
+       int i;
+
+       _tcscpy (name2, name);
+       i = _tcslen (name2) - 1;
+       while (i > 0) {
+               if (name2[i] == '.') {
+                       name2[i] = 0;
+                       break;
+               }
+               i--;
+       }
+       while (i > 0) {
+               if (name2[i] == '/' || name2[i] == '\\') {
+                       i++;
+                       break;
+               }
+               i--;
+       }
+       fetch_saveimagepath (path, sizeof path / sizeof (TCHAR), 1);
+       _stprintf (name1, L"%s%s_save.adf", path, name2 + i);
+       return name1;
+}
+
+static struct zfile *getwritefile (const TCHAR *name, bool *wrprot)
+{
+       struct zfile *zf;
+       DISK_validate_filename (DISK_get_saveimagepath (name), 1, wrprot, NULL, &zf);
+       return zf;
+}
+
+static int iswritefileempty (const TCHAR *name)
+{
+       struct zfile *zf;
+       bool wrprot;
+       uae_char buffer[8];
+       trackid td[MAX_TRACKS];
+       int tracks, ddhd, i, ret;
+
+       zf = getwritefile (name, &wrprot);
+       if (!zf) return 1;
+       zfile_fread (buffer, sizeof (char), 8, zf);
+       if (strncmp ((uae_char*)buffer, "UAE-1ADF", 8))
+               return 0;
+       ret = read_header_ext2 (zf, td, &tracks, &ddhd);
+       zfile_fclose (zf);
+       if (!ret)
+               return 1;
+       for (i = 0; i < tracks; i++) {
+               if (td[i].bitlen) return 0;
+       }
+       return 1;
+}
+
+static int openwritefile (drive *drv, int create)
+{
+       bool wrprot = 0;
+
+       drv->writediskfile = getwritefile (currprefs.floppyslots[drv - &floppy[0]].df, &wrprot);
+       if (drv->writediskfile) {
+               drv->wrprot = wrprot;
+               if (!read_header_ext2 (drv->writediskfile, drv->writetrackdata, &drv->write_num_tracks, 0)) {
+                       zfile_fclose (drv->writediskfile);
+                       drv->writediskfile = 0;
+                       drv->wrprot = 1;
+               } else {
+                       if (drv->write_num_tracks > drv->num_tracks)
+                               drv->num_tracks = drv->write_num_tracks;
+               }
+       } else if (zfile_iscompressed (drv->diskfile)) {
+               drv->wrprot = 1;
+       }
+       return drv->writediskfile ? 1 : 0;
+}
+
+static bool diskfile_iswriteprotect (const TCHAR *fname, int *needwritefile, drive_type *drvtype)
+{
+       struct zfile *zf1, *zf2;
+       bool wrprot1 = 0, wrprot2 = 1;
+       uae_char buffer[25];
+
+       *needwritefile = 0;
+       *drvtype = DRV_35_DD;
+       DISK_validate_filename (fname, 1, &wrprot1, NULL, &zf1);
+       if (!zf1)
+               return 1;
+       if (zfile_iscompressed (zf1)) {
+               wrprot1 = 1;
+               *needwritefile = 1;
+       }
+       zf2 = getwritefile (fname, &wrprot2);
+       zfile_fclose (zf2);
+       zfile_fread (buffer, sizeof (char), 25, zf1);
+       zfile_fclose (zf1);
+       if (strncmp ((uae_char*) buffer, "CAPS", 4) == 0) {
+               *needwritefile = 1;
+               return wrprot2;
+       }
+       if (strncmp ((uae_char*) buffer, "Formatted Disk Image file", 25) == 0) {
+               *needwritefile = 1;
+               return wrprot2;
+       }
+       if (strncmp ((uae_char*) buffer, "UAE-1ADF", 8) == 0) {
+               if (wrprot1)
+                       return wrprot2;
+               return wrprot1;
+       }
+       if (strncmp ((uae_char*) buffer, "UAE--ADF", 8) == 0) {
+               *needwritefile = 1;
+               return wrprot2;
+       }
+       if (memcmp (exeheader, buffer, sizeof exeheader) == 0)
+               return 0;
+       if (wrprot1)
+               return wrprot2;
+       return wrprot1;
+}
+
+static int drive_insert (drive * drv, struct uae_prefs *p, int dnum, const TCHAR *fname, bool fake)
+{
+       uae_u8 buffer[2 + 2 + 4 + 4];
+       trackid *tid;
+       int num_tracks, size;
+       int canauto;
+       const TCHAR *ext;
+
+       drive_image_free (drv);
+       DISK_validate_filename (fname, 1, &drv->wrprot, &drv->crc32, &drv->diskfile);
+       drv->ddhd = 1;
+       drv->num_secs = 0;
+       drv->hard_num_cyls = p->floppyslots[dnum].dfxtype == DRV_525_SD ? 40 : 80;
+       drv->tracktiming[0] = 0;
+       drv->useturbo = 0;
+       drv->indexoffset = 0;
+
+       gui_disk_image_change (dnum, fname, drv->wrprot);
+
+       canauto = 0;
+       ext = _tcsrchr (fname, '.');
+       if (ext) {
+               if (!_tcsicmp (ext + 1, L"adf") || !_tcsicmp (ext + 1, L"adz") || !_tcsicmp (ext + 1, L"st") || !_tcsicmp (ext + 1, L"ima") || !_tcsicmp (ext + 1, L"img")) 
+                       canauto = 1;
+       }
+
+       if (!drv->motoroff) {
+               drv->dskready_up_time = DSKREADY_UP_TIME;
+               drv->dskready_down_time = 0;
+       }
+
+       if (drv->diskfile == 0 && !drv->catweasel) {
+               track_reset (drv);
+               return 0;
+       }
+
+       if (!fake)
+               inprec_recorddiskchange (dnum, fname, drv->wrprot);
+
+       _tcsncpy (currprefs.floppyslots[dnum].df, fname, 255);
+       currprefs.floppyslots[dnum].df[255] = 0;
+       _tcsncpy (changed_prefs.floppyslots[dnum].df, fname, 255);
+       changed_prefs.floppyslots[dnum].df[255] = 0;
+       _tcscpy (drv->newname, fname);
+       gui_filename (dnum, fname);
+
+       memset (buffer, 0, sizeof buffer);
+       size = 0;
+       if (drv->diskfile) {
+               zfile_fread (buffer, sizeof (char), 8, drv->diskfile);
+               zfile_fseek (drv->diskfile, 0, SEEK_END);
+               size = zfile_ftell (drv->diskfile);
+               zfile_fseek (drv->diskfile, 0, SEEK_SET);
+       }
+
+       if (drv->catweasel) {
+
+               drv->wrprot = 1;
+               drv->filetype = ADF_CATWEASEL;
+               drv->num_tracks = 80;
+               drv->ddhd = 1;
+
+#ifdef CAPS
+       } else if (strncmp ((char*)buffer, "CAPS", 4) == 0) {
+
+               drv->wrprot = 1;
+               if (!caps_loadimage (drv->diskfile, drv - floppy, &num_tracks)) {
+                       zfile_fclose (drv->diskfile);
+                       drv->diskfile = 0;
+                       return 0;
+               }
+               drv->num_tracks = num_tracks;
+               drv->filetype = ADF_IPF;
+#endif
+#ifdef FDI2RAW
+       } else if (drv->fdi = fdi2raw_header (drv->diskfile)) {
+
+               drv->wrprot = 1;
+               drv->num_tracks = fdi2raw_get_last_track (drv->fdi);
+               drv->num_secs = fdi2raw_get_num_sector (drv->fdi);
+               drv->filetype = ADF_FDI;
+#endif
+       } else if (strncmp ((char*)buffer, "UAE-1ADF", 8) == 0) {
+
+               read_header_ext2 (drv->diskfile, drv->trackdata, &drv->num_tracks, &drv->ddhd);
+               drv->filetype = ADF_EXT2;
+               drv->num_secs = 11;
+               if (drv->ddhd > 1)
+                       drv->num_secs = 22;
+
+       } else if (strncmp ((char*)buffer, "UAE--ADF", 8) == 0) {
+               int offs = 160 * 4 + 8;
+               int i;
+
+               drv->wrprot = 1;
+               drv->filetype = ADF_EXT1;
+               drv->num_tracks = 160;
+               drv->num_secs = 11;
+
+               zfile_fseek (drv->diskfile, 8, SEEK_SET);
+               for (i = 0; i < 160; i++) {
+                       tid = &drv->trackdata[i];
+                       zfile_fread (buffer, 4, 1, drv->diskfile);
+                       tid->sync = buffer[0] * 256 + buffer[1];
+                       tid->len = buffer[2] * 256 + buffer[3];
+                       tid->offs = offs;
+                       tid->revolutions = 1;
+                       if (tid->sync == 0) {
+                               tid->type = TRACK_AMIGADOS;
+                               tid->bitlen = 0;
+                       } else {
+                               tid->type = TRACK_RAW1;
+                               tid->bitlen = tid->len * 8;
+                       }
+                       offs += tid->len;
+               }
+
+       } else if (memcmp (exeheader, buffer, sizeof exeheader) == 0) {
+               int i;
+               struct zfile *z = zfile_fopen_empty (NULL, L"", 512 * 1760);
+               createimagefromexe (drv->diskfile, z);
+               drv->filetype = ADF_NORMAL;
+               zfile_fclose (drv->diskfile);
+               drv->diskfile = z;
+               drv->num_tracks = 160;
+               drv->num_secs = 11;
+               for (i = 0; i < drv->num_tracks; i++) {
+                       tid = &drv->trackdata[i];
+                       tid->type = TRACK_AMIGADOS;
+                       tid->len = 512 * drv->num_secs;
+                       tid->bitlen = 0;
+                       tid->offs = i * 512 * drv->num_secs;
+                       tid->revolutions = 1;
+               }
+               drv->useturbo = 1;
+
+       } else if (canauto && (
+
+               // double sided
+               size == 9 * 80 * 2 * 512 || size == 18 * 80 * 2 * 512 || size == 10 * 80 * 2 * 512 || size == 20 * 80 * 2 * 512 ||
+               size == 9 * 81 * 2 * 512 || size == 18 * 81 * 2 * 512 || size == 10 * 81 * 2 * 512 || size == 20 * 81 * 2 * 512 ||
+               size == 9 * 82 * 2 * 512 || size == 18 * 82 * 2 * 512 || size == 10 * 82 * 2 * 512 || size == 20 * 82 * 2 * 512 ||
+               // single sided
+               size == 9 * 80 * 1 * 512 || size == 18 * 80 * 1 * 512 || size == 10 * 80 * 1 * 512 || size == 20 * 80 * 1 * 512 ||
+               size == 9 * 81 * 1 * 512 || size == 18 * 81 * 1 * 512 || size == 10 * 81 * 1 * 512 || size == 20 * 81 * 1 * 512 ||
+               size == 9 * 82 * 1 * 512 || size == 18 * 82 * 1 * 512 || size == 10 * 82 * 1 * 512 || size == 20 * 82 * 1 * 512)) {
+                       /* PC formatted image */
+                       int i, side;
+
+                       for (side = 2; side > 0; side--) {
+                               if (       size ==  9 * 80 * side * 512 || size ==  9 * 81 * side * 512 || size ==  9 * 82 * side * 512) {
+                                       drv->num_secs = 9;
+                                       drv->ddhd = 1;
+                                       break;
+                               } else if (size == 18 * 80 * side * 512 || size == 18 * 81 * side * 512 || size == 18 * 82 * side * 512) {
+                                       drv->num_secs = 18;
+                                       drv->ddhd = 2;
+                                       break;
+                               } else if (size == 10 * 80 * side * 512 || size == 10 * 81 * side * 512 || size == 10 * 82 * side * 512) {
+                                       drv->num_secs = 10;
+                                       drv->ddhd = 1;
+                                       break;
+                               } else if (size == 20 * 80 * side * 512 || size == 20 * 81 * side * 512 || size == 20 * 82 * side * 512) {
+                                       drv->num_secs = 20;
+                                       drv->ddhd = 2;
+                                       break;
+                               }
+                       }
+                       drv->num_tracks = size / (drv->num_secs * 512);
+
+                       drv->filetype = ADF_PCDOS;
+                       tid = &drv->trackdata[0];
+                       for (i = 0; i < drv->num_tracks; i++) {
+                               tid->type = TRACK_PCDOS;
+                               tid->len = 512 * drv->num_secs;
+                               tid->bitlen = 0;
+                               tid->offs = i * 512 * drv->num_secs;
+                               if (side == 1) {
+                                       tid++;
+                                       tid->type = TRACK_NONE;
+                                       tid->len = 512 * drv->num_secs;
+                               }
+                               tid->revolutions = 1;
+                               tid++;
+
+                       }
+                       if (side == 1)
+                               drv->num_tracks *= 2;
+
+       } else {
+               int i, ds;
+
+               ds = 0;
+               drv->filetype = ADF_NORMAL;
+
+               /* High-density or diskspare disk? */
+               drv->num_tracks = 0;
+               if (size > 160 * 11 * 512) { // larger than standard adf?
+                       for (i = 80; i <= 83; i++) {
+                               if (size == i * 22 * 512 * 2) { // HD
+                                       drv->ddhd = 2;
+                                       drv->num_tracks = size / (512 * (drv->num_secs = 22));
+                                       break;
+                               }
+                               if (size == i * 11 * 512 * 2) { // >80 cyl DD
+                                       drv->num_tracks = size / (512 * (drv->num_secs = 11));
+                                       break;
+                               }
+                               if (size == i * 12 * 512 * 2) { // ds 12 sectors
+                                       drv->num_tracks = size / (512 * (drv->num_secs = 12));
+                                       ds = 1;
+                                       break;
+                               }
+                               if (size == i * 24 * 512 * 2) { // ds 24 sectors
+                                       drv->num_tracks = size / (512 * (drv->num_secs = 24));
+                                       drv->ddhd = 2;
+                                       ds = 1;
+                                       break;
+                               }
+                       }
+                       if (drv->num_tracks == 0) {
+                               drv->num_tracks = size / (512 * (drv->num_secs = 22));
+                               drv->ddhd = 2;
+                       }
+               } else {
+                       drv->num_tracks = size / (512 * (drv->num_secs = 11));
+               }
+
+               if (!ds && drv->num_tracks > MAX_TRACKS)
+                       write_log (L"Your diskfile is too big, %d bytes!\n", size);
+               for (i = 0; i < drv->num_tracks; i++) {
+                       tid = &drv->trackdata[i];
+                       tid->type = ds ? TRACK_DISKSPARE : TRACK_AMIGADOS;
+                       tid->len = 512 * drv->num_secs;
+                       tid->bitlen = 0;
+                       tid->offs = i * 512 * drv->num_secs;
+                       tid->revolutions = 1;
+               }
+       }
+       openwritefile (drv, 0);
+       drive_settype_id (drv); /* Set DD or HD drive */
+       drive_fill_bigbuf (drv, 1);
+       drv->mfmpos = uaerand ();
+       drv->mfmpos |= (uaerand () << 16);
+       drv->mfmpos %= drv->tracklen;
+       drv->prevtracklen = 0;
+#ifdef DRIVESOUND
+       driveclick_insert (drv - floppy, 0);
+#endif
+       update_drive_gui (drv - floppy);
+       return 1;
+}
+
+static void rand_shifter (drive *drv)
+{
+       int r = ((uaerand () >> 4) & 7) + 1;
+       while (r-- > 0) {
+               word <<= 1;
+               word |= (uaerand () & 0x1000) ? 1 : 0;
+               bitoffset++;
+               bitoffset &= 15;
+       }
+}
+
+static void set_steplimit (drive *drv)
+{
+       drv->steplimit = 10;
+       drv->steplimitcycle = get_cycles ();
+}
+
+static int drive_empty (drive * drv)
+{
+#ifdef CATWEASEL
+       if (drv->catweasel)
+               return catweasel_disk_changed (drv->catweasel) == 0;
+#endif
+       return drv->diskfile == 0;
+}
+
+static void drive_step (drive * drv, int step_direction)
+{
+#ifdef CATWEASEL
+       if (drv->catweasel) {
+               int dir = direction ? -1 : 1;
+               catweasel_step (drv->catweasel, dir);
+               drv->cyl += dir;
+               if (drv->cyl < 0)
+                       drv->cyl = 0;
+               write_log (L"%d -> %d\n", dir, drv->cyl);
+               return;
+       }
+#endif
+       if (!drive_empty (drv))
+               drv->dskchange = 0;
+       if (drv->steplimit && get_cycles() - drv->steplimitcycle < MIN_STEPLIMIT_CYCLE) {
+               if (disk_debug_logging > 1)
+                       write_log (L" step ignored drive %d, %d",
+                       drv - floppy, (get_cycles() - drv->steplimitcycle) / CYCLE_UNIT);
+               return;
+       }
+       /* A1200's floppy drive needs at least 30 raster lines between steps
+       * but we'll use very small value for better compatibility with faster CPU emulation
+       * (stupid trackloaders with CPU delay loops)
+       */
+       set_steplimit (drv);
+       if (step_direction) {
+               if (drv->cyl) {
+                       drv->cyl--;
+#ifdef DRIVESOUND
+                       driveclick_click (drv - floppy, drv->cyl);
+#endif
+               }
+               /*      else
+               write_log (L"program tried to step beyond track zero\n");
+               "no-click" programs does that
+               */
+       } else {
+               int maxtrack = drv->hard_num_cyls;
+               if (drv->cyl < maxtrack + 3) {
+                       drv->cyl++;
+#ifdef CATWEASEL
+                       if (drv->catweasel)
+                               catweasel_step (drv->catweasel, 1);
+#endif
+               }
+               if (drv->cyl >= maxtrack)
+                       write_log (L"program tried to step over track %d\n", maxtrack);
+#ifdef DRIVESOUND
+               driveclick_click (drv - floppy, drv->cyl);
+#endif
+       }
+       rand_shifter (drv);
+       if (disk_debug_logging > 1)
+               write_log (L" ->step %d", drv->cyl);
+}
+
+static int drive_track0 (drive * drv)
+{
+#ifdef CATWEASEL
+       if (drv->catweasel)
+               return catweasel_track0 (drv->catweasel);
+#endif
+       return drv->cyl == 0;
+}
+
+static int drive_writeprotected (drive * drv)
+{
+#ifdef CATWEASEL
+       if (drv->catweasel)
+               return 1;
+#endif
+       return drv->wrprot || drv->diskfile == NULL;
+}
+
+static int drive_running (drive * drv)
+{
+       return !drv->motoroff;
+}
+
+static void motordelay_func (uae_u32 v)
+{
+       floppy[v].motordelay = 0;
+}
+
+static void drive_motor (drive * drv, bool off)
+{
+       if (drv->motoroff && !off) {
+               drv->dskready_up_time = DSKREADY_UP_TIME;
+               rand_shifter (drv);
+#ifdef DRIVESOUND
+               driveclick_motor (drv - floppy, drv->dskready_down_time == 0 ? 2 : 1);
+#endif
+               if (disk_debug_logging > 1)
+                       write_log (L" ->motor on");
+       }
+       if (!drv->motoroff && off) {
+               drv->drive_id_scnt = 0; /* Reset id shift reg counter */
+               drv->dskready_down_time = DSKREADY_DOWN_TIME;
+#ifdef DRIVESOUND
+               driveclick_motor (drv - floppy, 0);
+#endif
+#ifdef DEBUG_DRIVE_ID
+               write_log (L"drive_motor: Selected DF%d: reset id shift reg.\n",drv-floppy);
+#endif
+               if (disk_debug_logging > 1)
+                       write_log (L" ->motor off");
+               if (currprefs.cpu_model <= 68010 && currprefs.m68k_speed == 0) {
+                       drv->motordelay = 1;
+                       event2_newevent2 (30, drv - floppy, motordelay_func);
+               }
+       }
+       drv->motoroff = off;
+       if (drv->motoroff) {
+               drv->dskready = 0;
+               drv->dskready_up_time = 0;
+       } else {
+               drv->dskready_down_time = 0;
+       }
+#ifdef CATWEASEL
+       if (drv->catweasel)
+               catweasel_set_motor (drv->catweasel, !drv->motoroff);
+#endif
+}
+
+static void read_floppy_data (struct zfile *diskfile, trackid *tid, int offset, uae_u8 *dst, int len)
+{
+       if (len == 0)
+               return;
+       zfile_fseek (diskfile, tid->offs + offset, SEEK_SET);
+       zfile_fread (dst, 1, len, diskfile);
+}
+
+/* Megalomania does not like zero MFM words... */
+static void mfmcode (uae_u16 * mfm, int words)
+{
+       uae_u32 lastword = 0;
+       while (words--) {
+               uae_u32 v = *mfm;
+               uae_u32 lv = (lastword << 16) | v;
+               uae_u32 nlv = 0x55555555 & ~lv;
+               uae_u32 mfmbits = (nlv << 1) & (nlv >> 1);
+               *mfm++ = v | mfmbits;
+               lastword = v;
+       }
+}
+
+static uae_u8 mfmencodetable[16] = {
+       0x2a, 0x29, 0x24, 0x25, 0x12, 0x11, 0x14, 0x15,
+       0x4a, 0x49, 0x44, 0x45, 0x52, 0x51, 0x54, 0x55
+};
+
+
+static uae_u16 dos_encode_byte (uae_u8 byte)
+{
+       uae_u8 b2, b1;
+       uae_u16 word;
+
+       b1 = byte;
+       b2 = b1 >> 4;
+       b1 &= 15;
+       word = mfmencodetable[b2] <<8 | mfmencodetable[b1];
+       return (word | ((word & (256 | 64)) ? 0 : 128));
+}
+
+static uae_u16 *mfmcoder (uae_u8 *src, uae_u16 *dest, int len)
+{
+       int i;
+
+       for (i = 0; i < len; i++) {
+               *dest = dos_encode_byte (*src++);
+               *dest |= ((dest[-1] & 1)||(*dest & 0x4000)) ? 0: 0x8000;
+               dest++;
+       }
+       return dest;
+}
+
+static void decode_pcdos (drive *drv)
+{
+       int i, len;
+       int tr = drv->cyl * 2 + side;
+       uae_u16 *dstmfmbuf, *mfm2;
+       uae_u8 secbuf[1000];
+       uae_u16 crc16;
+       trackid *ti = drv->trackdata + tr;
+       int tracklen = 12500;
+
+       mfm2 = drv->bigmfmbuf;
+       *mfm2++ = 0x9254;
+       memset (secbuf, 0x4e, 40);
+       memset (secbuf + 40, 0x00, 12);
+       secbuf[52] = 0xc2;
+       secbuf[53] = 0xc2;
+       secbuf[54] = 0xc2;
+       secbuf[55] = 0xfc;
+       memset (secbuf + 56, 0x4e, 40);
+       dstmfmbuf = mfmcoder (secbuf, mfm2, 96);
+       mfm2[52] = 0x5224;
+       mfm2[53] = 0x5224;
+       mfm2[54] = 0x5224;
+       for (i = 0; i < drv->num_secs; i++) {
+               mfm2 = dstmfmbuf;
+               memset (secbuf, 0x00, 12);
+               secbuf[12] = 0xa1;
+               secbuf[13] = 0xa1;
+               secbuf[14] = 0xa1;
+               secbuf[15] = 0xfe;
+               secbuf[16] = drv->cyl;
+               secbuf[17] = side;
+               secbuf[18] = 1 + i;
+               secbuf[19] = 2; // 128 << 2 = 512
+               crc16 = get_crc16(secbuf + 12, 3 + 1 + 4);
+               secbuf[20] = crc16 >> 8;
+               secbuf[21] = crc16 & 0xff;
+               memset(secbuf + 22, 0x4e, 22);
+               memset(secbuf + 44, 0x00, 12);
+               secbuf[56] = 0xa1;
+               secbuf[57] = 0xa1;
+               secbuf[58] = 0xa1;
+               secbuf[59] = 0xfb;
+               read_floppy_data (drv->diskfile, ti, i * 512, &secbuf[60], 512);
+               crc16 = get_crc16 (secbuf + 56, 3 + 1 + 512);
+               secbuf[60 + 512] = crc16 >> 8;
+               secbuf[61 + 512] = crc16 & 0xff;
+               len = (tracklen / 2 - 96) / drv->num_secs - 574 / drv->ddhd;
+               if (len > 0)
+                       memset(secbuf + 512 + 62, 0x4e, len);
+               dstmfmbuf = mfmcoder (secbuf, mfm2, 60 + 512 + 2 + 76 / drv->ddhd);
+               mfm2[12] = 0x4489;
+               mfm2[13] = 0x4489;
+               mfm2[14] = 0x4489;
+               mfm2[56] = 0x4489;
+               mfm2[57] = 0x4489;
+               mfm2[58] = 0x4489;
+       }
+       while (dstmfmbuf - drv->bigmfmbuf < tracklen / 2)
+               *dstmfmbuf++ = 0x9254;
+       drv->skipoffset = 0;
+       drv->tracklen = (dstmfmbuf - drv->bigmfmbuf) * 16;
+       if (disk_debug_logging > 0)
+               write_log (L"pcdos read track %d\n", tr);
+}
+
+static void decode_amigados (drive *drv)
+{
+       /* Normal AmigaDOS format track */
+       int tr = drv->cyl * 2 + side;
+       int sec;
+       int dstmfmoffset = 0;
+       uae_u16 *dstmfmbuf = drv->bigmfmbuf;
+       int len = drv->num_secs * 544 + FLOPPY_GAP_LEN;
+
+       trackid *ti = drv->trackdata + tr;
+       memset (dstmfmbuf, 0xaa, len * 2);
+       dstmfmoffset += FLOPPY_GAP_LEN;
+       drv->skipoffset = (FLOPPY_GAP_LEN * 8) / 3 * 2;
+       drv->tracklen = len * 2 * 8;
+
+       for (sec = 0; sec < drv->num_secs; sec++) {
+               uae_u8 secbuf[544];
+               uae_u16 mfmbuf[544];
+               int i;
+               uae_u32 deven, dodd;
+               uae_u32 hck = 0, dck = 0;
+
+               secbuf[0] = secbuf[1] = 0x00;
+               secbuf[2] = secbuf[3] = 0xa1;
+               secbuf[4] = 0xff;
+               secbuf[5] = tr;
+               secbuf[6] = sec;
+               secbuf[7] = drv->num_secs - sec;
+
+               for (i = 8; i < 24; i++)
+                       secbuf[i] = 0;
+
+               read_floppy_data (drv->diskfile, ti, sec * 512, &secbuf[32], 512);
+
+               mfmbuf[0] = mfmbuf[1] = 0xaaaa;
+               mfmbuf[2] = mfmbuf[3] = 0x4489;
+
+               deven = ((secbuf[4] << 24) | (secbuf[5] << 16)
+                       | (secbuf[6] << 8) | (secbuf[7]));
+               dodd = deven >> 1;
+               deven &= 0x55555555;
+               dodd &= 0x55555555;
+
+               mfmbuf[4] = dodd >> 16;
+               mfmbuf[5] = dodd;
+               mfmbuf[6] = deven >> 16;
+               mfmbuf[7] = deven;
+
+               for (i = 8; i < 48; i++)
+                       mfmbuf[i] = 0xaaaa;
+               for (i = 0; i < 512; i += 4) {
+                       deven = ((secbuf[i + 32] << 24) | (secbuf[i + 33] << 16)
+                               | (secbuf[i + 34] << 8) | (secbuf[i + 35]));
+                       dodd = deven >> 1;
+                       deven &= 0x55555555;
+                       dodd &= 0x55555555;
+                       mfmbuf[(i >> 1) + 32] = dodd >> 16;
+                       mfmbuf[(i >> 1) + 33] = dodd;
+                       mfmbuf[(i >> 1) + 256 + 32] = deven >> 16;
+                       mfmbuf[(i >> 1) + 256 + 33] = deven;
+               }
+
+               for (i = 4; i < 24; i += 2)
+                       hck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];
+
+               deven = dodd = hck;
+               dodd >>= 1;
+               mfmbuf[24] = dodd >> 16;
+               mfmbuf[25] = dodd;
+               mfmbuf[26] = deven >> 16;
+               mfmbuf[27] = deven;
+
+               for (i = 32; i < 544; i += 2)
+                       dck ^= (mfmbuf[i] << 16) | mfmbuf[i + 1];
+
+               deven = dodd = dck;
+               dodd >>= 1;
+               mfmbuf[28] = dodd >> 16;
+               mfmbuf[29] = dodd;
+               mfmbuf[30] = deven >> 16;
+               mfmbuf[31] = deven;
+               mfmcode (mfmbuf + 4, 544 - 4);
+
+               for (i = 0; i < 544; i++) {
+                       dstmfmbuf[dstmfmoffset % len] = mfmbuf[i];
+                       dstmfmoffset++;
+               }
+       }
+
+       if (disk_debug_logging > 0)
+               write_log (L"amigados read track %d\n", tr);
+}
+
+/*
+* diskspare format
+*
+* 0 <4489> <4489> 0 track sector crchi, crclo, data[512] (520 bytes per sector)
+*
+* 0xAAAA 0x4489 0x4489 0x2AAA oddhi, oddlo, evenhi, evenlo, ...
+*
+* NOTE: data is MFM encoded using same method as ADOS header, not like ADOS data!
+*
+*/
+
+static void decode_diskspare (drive *drv)
+{
+       int tr = drv->cyl * 2 + side;
+       int sec;
+       int dstmfmoffset = 0;
+       int size = 512 + 8;
+       uae_u16 *dstmfmbuf = drv->bigmfmbuf;
+       int len = drv->num_secs * size + FLOPPY_GAP_LEN;
+
+       trackid *ti = drv->trackdata + tr;
+       memset (dstmfmbuf, 0xaa, len * 2);
+       dstmfmoffset += FLOPPY_GAP_LEN;
+       drv->skipoffset = (FLOPPY_GAP_LEN * 8) / 3 * 2;
+       drv->tracklen = len * 2 * 8;
+
+       for (sec = 0; sec < drv->num_secs; sec++) {
+               uae_u8 secbuf[512 + 8];
+               uae_u16 mfmbuf[512 + 8];
+               int i;
+               uae_u32 deven, dodd;
+               uae_u16 chk;
+
+               secbuf[0] = tr;
+               secbuf[1] = sec;
+               secbuf[2] = 0;
+               secbuf[3] = 0;
+
+               read_floppy_data (drv->diskfile, ti, sec * 512, &secbuf[4], 512);
+
+               mfmbuf[0] = 0xaaaa;
+               mfmbuf[1] = 0x4489;
+               mfmbuf[2] = 0x4489;
+               mfmbuf[3] = 0x2aaa;
+
+               for (i = 0; i < 512; i += 4) {
+                       deven = ((secbuf[i + 4] << 24) | (secbuf[i + 5] << 16)
+                               | (secbuf[i + 6] << 8) | (secbuf[i + 7]));
+                       dodd = deven >> 1;
+                       deven &= 0x55555555;
+                       dodd &= 0x55555555;
+                       mfmbuf[i + 8 + 0] = dodd >> 16;
+                       mfmbuf[i + 8 + 1] = dodd;
+                       mfmbuf[i + 8 + 2] = deven >> 16;
+                       mfmbuf[i + 8 + 3] = deven;
+               }
+               mfmcode (mfmbuf + 8, 512);
+
+               i = 8;
+               chk = mfmbuf[i++] & 0x7fff;
+               while (i < 512 + 8)
+                       chk ^= mfmbuf[i++];
+               secbuf[2] = chk >> 8;
+               secbuf[3] = chk;
+
+               deven = ((secbuf[0] << 24) | (secbuf[1] << 16)
+                       | (secbuf[2] << 8) | (secbuf[3]));
+               dodd = deven >> 1;
+               deven &= 0x55555555;
+               dodd &= 0x55555555;
+
+               mfmbuf[4] = dodd >> 16;
+               mfmbuf[5] = dodd;
+               mfmbuf[6] = deven >> 16;
+               mfmbuf[7] = deven;
+               mfmcode (mfmbuf + 4, 4);
+
+               for (i = 0; i < 512 + 8; i++) {
+                       dstmfmbuf[dstmfmoffset % len] = mfmbuf[i];
+                       dstmfmoffset++;
+               }
+       }
+
+       if (disk_debug_logging > 0)
+               write_log (L"diskspare read track %d\n", tr);
+}
+
+static void drive_fill_bigbuf (drive * drv, int force)
+{
+       int tr = drv->cyl * 2 + side;
+       trackid *ti = drv->trackdata + tr;
+
+       if ((!drv->diskfile && !drv->catweasel) || tr >= drv->num_tracks) {
+               track_reset (drv);
+               return;
+       }
+
+       if (!force && drv->catweasel) {
+               drv->buffered_cyl = -1;
+               return;
+       }
+
+       if (!force && drv->buffered_cyl == drv->cyl && drv->buffered_side == side)
+               return;
+       drv->indexoffset = 0;
+       drv->multi_revolution = 0;
+       drv->tracktiming[0] = 0;
+       drv->skipoffset = -1;
+       drv->revolutions = 1;
+
+       if (drv->writediskfile && drv->writetrackdata[tr].bitlen > 0) {
+               int i;
+               trackid *wti = &drv->writetrackdata[tr];
+               drv->tracklen = wti->bitlen;
+               drv->revolutions = wti->revolutions;
+               read_floppy_data (drv->writediskfile, wti, 0, (uae_u8*)drv->bigmfmbuf, (wti->bitlen + 7) / 8);
+               for (i = 0; i < (drv->tracklen + 15) / 16; i++) {
+                       uae_u16 *mfm = drv->bigmfmbuf + i;
+                       uae_u8 *data = (uae_u8 *) mfm;
+                       *mfm = 256 * *data + *(data + 1);
+               }
+               if (disk_debug_logging > 0)
+                       write_log (L"track %d, length %d read from \"saveimage\"\n", tr, drv->tracklen);
+       } else if (drv->filetype == ADF_CATWEASEL) {
+#ifdef CATWEASEL
+               drv->tracklen = 0;
+               if (!catweasel_disk_changed (drv->catweasel)) {
+                       drv->tracklen = catweasel_fillmfm (drv->catweasel, drv->bigmfmbuf, side, drv->ddhd, 0);
+               }
+               drv->buffered_cyl = -1;
+               if (!drv->tracklen) {
+                       track_reset (drv);
+                       return;
+               }
+#endif
+       } else if (drv->filetype == ADF_IPF) {
+
+#ifdef CAPS
+               caps_loadtrack (drv->bigmfmbuf, drv->tracktiming, drv - floppy, tr, &drv->tracklen, &drv->multi_revolution, &drv->skipoffset);
+#endif
+
+       } else if (drv->filetype == ADF_FDI) {
+
+#ifdef FDI2RAW
+               fdi2raw_loadtrack (drv->fdi, drv->bigmfmbuf, drv->tracktiming, tr, &drv->tracklen, &drv->indexoffset, &drv->multi_revolution, 1);
+#endif
+
+       } else if (ti->type == TRACK_PCDOS) {
+
+               decode_pcdos (drv);
+
+       } else if (ti->type == TRACK_AMIGADOS) {
+
+               decode_amigados (drv);
+
+       } else if (ti->type == TRACK_DISKSPARE) {
+
+               decode_diskspare (drv);
+
+       } else if (ti->type == TRACK_NONE) {
+
+               ;
+
+       } else {
+               int i;
+               int base_offset = ti->type == TRACK_RAW ? 0 : 1;
+               drv->tracklen = ti->bitlen + 16 * base_offset;
+               drv->bigmfmbuf[0] = ti->sync;
+               read_floppy_data (drv->diskfile, ti, 0, (uae_u8*)(drv->bigmfmbuf + base_offset), (ti->bitlen + 7) / 8);
+               for (i = base_offset; i < (drv->tracklen + 15) / 16; i++) {
+                       uae_u16 *mfm = drv->bigmfmbuf + i;
+                       uae_u8 *data = (uae_u8 *) mfm;
+                       *mfm = 256 * *data + *(data + 1);
+               }
+               if (disk_debug_logging > 1)
+                       write_log (L"rawtrack %d image offset=%x\n", tr, ti->offs);
+       }
+       drv->buffered_side = side;
+       drv->buffered_cyl = drv->cyl;
+       if (drv->tracklen == 0) {
+               drv->tracklen = FLOPPY_WRITE_LEN * drv->ddhd * 2 * 8;
+               memset (drv->bigmfmbuf, 0, FLOPPY_WRITE_LEN * 2 * drv->ddhd);
+       }
+
+       drv->trackspeed = get_floppy_speed2 (drv);
+       updatemfmpos (drv);
+}
+
+/* Update ADF_EXT2 track header */
+static void diskfile_update (struct zfile *diskfile, trackid *ti, int len, image_tracktype type)
+{
+       uae_u8 buf[2 + 2 + 4 + 4], *zerobuf;
+
+       ti->revolutions = 1;
+       ti->bitlen = len;
+       zfile_fseek (diskfile, 8 + 4 + (2 + 2 + 4 + 4) * ti->track, SEEK_SET);
+       memset (buf, 0, sizeof buf);
+       ti->type = type;
+       buf[2] = 0;
+       buf[3] = ti->type;
+       do_put_mem_long ((uae_u32 *) (buf + 4), ti->len);
+       do_put_mem_long ((uae_u32 *) (buf + 8), ti->bitlen);
+       zfile_fwrite (buf, sizeof buf, 1, diskfile);
+       if (ti->len > (len + 7) / 8) {
+               zerobuf = xmalloc (uae_u8, ti->len);
+               memset (zerobuf, 0, ti->len);
+               zfile_fseek (diskfile, ti->offs, SEEK_SET);
+               zfile_fwrite (zerobuf, 1, ti->len, diskfile);
+               free (zerobuf);
+       }
+       if (disk_debug_logging > 0)
+               write_log (L"track %d, raw track length %d written (total size %d)\n", ti->track, (ti->bitlen + 7) / 8, ti->len);
+}
+
+#define MFMMASK 0x55555555
+static uae_u16 getmfmword (uae_u16 *mbuf, int shift)
+{
+       return (mbuf[0] << shift) | (mbuf[1] >> (16 - shift));
+}
+
+static uae_u32 getmfmlong (uae_u16 *mbuf, int shift)
+{
+       return ((getmfmword (mbuf, shift) << 16) | getmfmword (mbuf + 1, shift)) & MFMMASK;
+}
+
+static int decode_buffer (uae_u16 *mbuf, int cyl, int drvsec, int ddhd, int filetype, int *drvsecp, int *sectable, int checkmode)
+{
+       int i, secwritten = 0;
+       int fwlen = FLOPPY_WRITE_LEN * ddhd;
+       int length = 2 * fwlen;
+       uae_u32 odd, even, chksum, id, dlong;
+       uae_u8 *secdata;
+       uae_u8 secbuf[544];
+       uae_u16 *mend = mbuf + length;
+       int shift = 0;
+
+       memset (sectable, 0, MAX_SECTORS * sizeof (int));
+       memcpy (mbuf + fwlen, mbuf, fwlen * sizeof (uae_u16));
+       mend -= (4 + 16 + 8 + 512);
+       while (secwritten < drvsec) {
+               int trackoffs;
+
+               while (getmfmword (mbuf, shift) != 0x4489) {
+                       if (mbuf >= mend)
+                               return 1;
+                       shift++;
+                       if (shift == 16) {
+                               shift = 0;
+                               mbuf++;
+                       }
+               }
+               while (getmfmword (mbuf, shift) == 0x4489) {
+                       if (mbuf >= mend)
+                               return 1;
+                       mbuf++;
+               }
+
+               odd = getmfmlong (mbuf, shift);
+               even = getmfmlong (mbuf + 2, shift);
+               mbuf += 4;
+               id = (odd << 1) | even;
+
+               trackoffs = (id & 0xff00) >> 8;
+               if (trackoffs + 1 > drvsec) {
+                       write_log (L"Disk decode: weird sector number %d (%04x)\n", trackoffs, id);
+                       if (filetype == ADF_EXT2)
+                               return 2;
+                       continue;
+               }
+               chksum = odd ^ even;
+               for (i = 0; i < 4; i++) {
+                       odd = getmfmlong (mbuf, shift);
+                       even = getmfmlong (mbuf + 8, shift);
+                       mbuf += 2;
+
+                       dlong = (odd << 1) | even;
+                       if (dlong && !checkmode) {
+                               if (filetype == ADF_EXT2)
+                                       return 6;
+                               secwritten = -200;
+                       }
+                       chksum ^= odd ^ even;
+               }   /* could check here if the label is nonstandard */
+               mbuf += 8;
+               odd = getmfmlong (mbuf, shift);
+               even = getmfmlong (mbuf + 2, shift);
+               mbuf += 4;
+               if (((odd << 1) | even) != chksum || ((id & 0x00ff0000) >> 16) != cyl * 2 + side) {
+                       write_log (L"Disk decode: checksum error on sector %d header\n", trackoffs);
+                       if (filetype == ADF_EXT2)
+                               return 3;
+                       continue;
+               }
+               odd = getmfmlong (mbuf, shift);
+               even = getmfmlong (mbuf + 2, shift);
+               mbuf += 4;
+               chksum = (odd << 1) | even;
+               secdata = secbuf + 32;
+               for (i = 0; i < 128; i++) {
+                       odd = getmfmlong (mbuf, shift);
+                       even = getmfmlong (mbuf + 256, shift);
+                       mbuf += 2;
+                       dlong = (odd << 1) | even;
+                       *secdata++ = dlong >> 24;
+                       *secdata++ = dlong >> 16;
+                       *secdata++ = dlong >> 8;
+                       *secdata++ = dlong;
+                       chksum ^= odd ^ even;
+               }
+               if (chksum) {
+                       write_log (L"Disk decode: sector %d, data checksum error\n", trackoffs);
+                       if (filetype == ADF_EXT2)
+                               return 4;
+                       continue;
+               }
+               mbuf += 256;
+               sectable[trackoffs] = 1;
+               secwritten++;
+               memcpy (writebuffer + trackoffs * 512, secbuf + 32, 512);
+       }
+       if (filetype == ADF_EXT2 && (secwritten == 0 || secwritten < 0))
+               return 5;
+       if (secwritten == 0)
+               write_log (L"Disk decode: unsupported format\n");
+       if (secwritten < 0)
+               write_log (L"Disk decode: sector labels ignored\n");
+       *drvsecp = drvsec;
+       return 0;
+}
+
+static uae_u8 mfmdecode (uae_u16 **mfmp, int shift)
+{
+       uae_u16 mfm = getmfmword (*mfmp, shift);
+       uae_u8 out = 0;
+       int i;
+
+       (*mfmp)++;
+       mfm &= 0x5555;
+       for (i = 0; i < 8; i++) {
+               out >>= 1;
+               if (mfm & 1)
+                       out |= 0x80;
+               mfm >>= 2;
+       }
+       return out;
+}
+
+static int drive_write_pcdos (drive *drv)
+{
+       int i;
+       int drvsec = drv->num_secs;
+       int fwlen = FLOPPY_WRITE_LEN * drv->ddhd;
+       int length = 2 * fwlen;
+       uae_u16 *mbuf = drv->bigmfmbuf;
+       uae_u16 *mend = mbuf + length;
+       int secwritten = 0, shift = 0, sector = -1;
+       int sectable[18];
+       uae_u8 secbuf[3 + 1 + 512];
+       uae_u8 mark;
+       uae_u16 crc;
+
+       memset (sectable, 0, sizeof sectable);
+       memcpy (mbuf + fwlen, mbuf, fwlen * sizeof (uae_u16));
+       mend -= 518;
+       secbuf[0] = secbuf[1] = secbuf[2] = 0xa1;
+       secbuf[3] = 0xfb;
+
+       while (secwritten < drvsec) {
+               while (getmfmword (mbuf, shift) != 0x4489) {
+                       if (mbuf >= mend)
+                               return 1;
+                       shift++;
+                       if (shift == 16) {
+                               shift = 0;
+                               mbuf++;
+                       }
+               }
+               while (getmfmword (mbuf, shift) == 0x4489) {
+                       if (mbuf >= mend)
+                               return 1;
+                       mbuf++;
+               }
+               mark = mfmdecode(&mbuf, shift);
+               if (mark == 0xfe) {
+                       uae_u8 tmp[8];
+                       uae_u8 cyl, head, size;
+
+                       cyl = mfmdecode (&mbuf, shift);
+                       head = mfmdecode (&mbuf, shift);
+                       sector = mfmdecode (&mbuf, shift);
+                       size = mfmdecode (&mbuf, shift);
+                       crc = (mfmdecode (&mbuf, shift) << 8) | mfmdecode (&mbuf, shift);
+
+                       tmp[0] = 0xa1; tmp[1] = 0xa1; tmp[2] = 0xa1; tmp[3] = mark;
+                       tmp[4] = cyl; tmp[5] = head; tmp[6] = sector; tmp[7] = size;
+                       if (get_crc16 (tmp, 8) != crc || cyl != drv->cyl || head != side || size != 2 || sector < 1 || sector > drv->num_secs) {
+                               write_log (L"PCDOS: track %d, corrupted sector header\n", drv->cyl * 2 + side);
+                               return 1;
+                       }
+                       sector--;
+                       continue;
+               }
+               if (mark != 0xfb) {
+                       write_log (L"PCDOS: track %d: unknown address mark %02X\n", drv->cyl * 2 + side, mark);
+                       continue;
+               }
+               if (sector < 0)
+                       continue;
+               for (i = 0; i < 512; i++)
+                       secbuf[i + 4] = mfmdecode (&mbuf, shift);
+               crc = (mfmdecode (&mbuf, shift) << 8) | mfmdecode (&mbuf, shift);
+               if (get_crc16 (secbuf, 3 + 1 + 512) != crc) {
+                       write_log (L"PCDOS: track %d, sector %d data checksum error\n",
+                               drv->cyl * 2 + side, sector + 1);
+                       continue;
+               }
+               sectable[sector] = 1;
+               secwritten++;
+               zfile_fseek (drv->diskfile, drv->trackdata[drv->cyl * 2 + side].offs + sector * 512, SEEK_SET);
+               zfile_fwrite (secbuf + 4, sizeof (uae_u8), 512, drv->diskfile);
+               write_log (L"PCDOS: track %d sector %d written\n", drv->cyl * 2 + side, sector + 1);
+               sector = -1;
+       }
+       if (secwritten != drv->num_secs)
+               write_log (L"PCDOS: track %d, %d corrupted sectors ignored\n",
+               drv->cyl * 2 + side, drv->num_secs - secwritten);
+       return 0;
+}
+
+static int drive_write_adf_amigados (drive *drv)
+{
+       int drvsec, i;
+       int sectable[MAX_SECTORS];
+
+       if (decode_buffer (drv->bigmfmbuf, drv->cyl, drv->num_secs, drv->ddhd, drv->filetype, &drvsec, sectable, 0))
+               return 2;
+       if (!drvsec)
+               return 2;
+
+       if (drv->filetype == ADF_EXT2)
+               diskfile_update (drv->diskfile, &drv->trackdata[drv->cyl * 2 + side], drvsec * 512 * 8, TRACK_AMIGADOS);
+       for (i = 0; i < drvsec; i++) {
+               zfile_fseek (drv->diskfile, drv->trackdata[drv->cyl * 2 + side].offs + i * 512, SEEK_SET);
+               zfile_fwrite (writebuffer + i * 512, sizeof (uae_u8), 512, drv->diskfile);
+       }
+
+       return 0;
+}
+
+/* write raw track to disk file */
+static int drive_write_ext2 (uae_u16 *bigmfmbuf, struct zfile *diskfile, trackid *ti, int tracklen)
+{
+       int len, i;
+
+       len = (tracklen + 7) / 8;
+       if (len > ti->len) {
+               write_log (L"disk raw write: image file's track %d is too small (%d < %d)!\n", ti->track, ti->len, len);
+               len = ti->len;
+       }
+       diskfile_update (diskfile, ti, tracklen, TRACK_RAW);
+       for (i = 0; i < ti->len / 2; i++) {
+               uae_u16 *mfm = bigmfmbuf + i;
+               uae_u16 *mfmw = bigmfmbufw + i;
+               uae_u8 *data = (uae_u8 *) mfm;
+               *mfmw = 256 * *data + *(data + 1);
+       }
+       zfile_fseek (diskfile, ti->offs, SEEK_SET);
+       zfile_fwrite (bigmfmbufw, 1, len, diskfile);
+       return 1;
+}
+
+static void drive_write_data (drive * drv)
+{
+       int ret = -1;
+       int tr = drv->cyl * 2 + side;
+       static int warned;
+
+       if (drive_writeprotected (drv) || drv->trackdata[tr].type == TRACK_NONE) {
+               /* read original track back because we didn't really write anything */
+               drv->buffered_side = 2;
+               return;
+       }
+       if (drv->writediskfile) {
+               drive_write_ext2 (drv->bigmfmbuf, drv->writediskfile, &drv->writetrackdata[tr],
+                       longwritemode ? dsklength2 * 8 : drv->tracklen);
+       }
+       switch (drv->filetype) {
+       case ADF_NORMAL:
+               if (drive_write_adf_amigados (drv)) {
+                       if (!warned)
+                               notify_user (NUMSG_NEEDEXT2);
+                       warned = 1;
+               }
+               return;
+       case ADF_EXT1:
+               break;
+       case ADF_EXT2:
+               if (!longwritemode)
+                       ret = drive_write_adf_amigados (drv);
+               if (ret) {
+                       write_log (L"not an amigados track %d (error %d), writing as raw track\n", drv->cyl * 2 + side, ret);
+                       drive_write_ext2 (drv->bigmfmbuf, drv->diskfile, &drv->trackdata[drv->cyl * 2 + side],
+                               longwritemode ? dsklength2 * 8 : drv->tracklen);
+               }
+               return;
+       case ADF_IPF:
+               break;
+       case ADF_PCDOS:
+               ret = drive_write_pcdos (drv);
+               if (ret)
+                       write_log (L"not a PC formatted track %d (error %d)\n", drv->cyl * 2 + side, ret);
+               break;
+       }
+       drv->tracktiming[0] = 0;
+}
+
+static void drive_eject (drive * drv)
+{
+#ifdef DRIVESOUND
+       driveclick_insert (drv - floppy, 1);
+#endif
+       gui_disk_image_change (drv - floppy, NULL, drv->wrprot);
+       drive_image_free (drv);
+       drv->dskchange = 1;
+       drv->ddhd = 1;
+       drv->dskchange_time = 0;
+       drv->dskready = 0;
+       drv->dskready_up_time = 0;
+       drv->dskready_down_time = 0;
+       drv->crc32 = 0;
+       drive_settype_id (drv); /* Back to 35 DD */
+       if (disk_debug_logging > 0)
+               write_log (L"eject drive %d\n", drv - &floppy[0]);
+       inprec_recorddiskchange (drv - floppy, NULL, false);
+}
+
+/* We use this function if we have no Kickstart ROM.
+* No error checking - we trust our luck. */
+void DISK_ersatz_read (int tr, int sec, uaecptr dest)
+{
+       uae_u8 *dptr = get_real_address (dest);
+       zfile_fseek (floppy[0].diskfile, floppy[0].trackdata[tr].offs + sec * 512, SEEK_SET);
+       zfile_fread (dptr, 1, 512, floppy[0].diskfile);
+}
+
+static void floppy_get_bootblock (uae_u8 *dst, bool ffs, bool bootable)
+{
+       strcpy ((char*)dst, "DOS");
+       dst[3] = ffs ? 1 : 0;
+       if (bootable)
+               memcpy (dst, ffs ? bootblock_ffs : bootblock_ofs, ffs ? sizeof bootblock_ffs : sizeof bootblock_ofs);
+}
+static void floppy_get_rootblock (uae_u8 *dst, int block, const TCHAR *disk_name, drive_type adftype)
+{
+       dst[0+3] = 2;
+       dst[12+3] = 0x48;
+       dst[312] = dst[313] = dst[314] = dst[315] = (uae_u8)0xff;
+       dst[316+2] = (block + 1) >> 8; dst[316+3] = (block + 1) & 255;
+       char *s = ua ((disk_name && _tcslen (disk_name) > 0) ? disk_name : L"empty");
+       dst[432] = strlen (s);
+       strcpy ((char*)dst + 433, s);
+       xfree (s);
+       dst[508 + 3] = 1;
+       disk_date (dst + 420);
+       memcpy (dst + 472, dst + 420, 3 * 4);
+       memcpy (dst + 484, dst + 420, 3 * 4);
+       disk_checksum (dst, dst + 20);
+       /* bitmap block */
+       memset (dst + 512 + 4, 0xff, 2 * block / 8);
+       if (adftype == 0)
+               dst[512 + 0x72] = 0x3f;
+       else
+               dst[512 + 0xdc] = 0x3f;
+       disk_checksum (dst + 512, dst + 512);
+}
+
+/* type: 0=regular, 1=ext2adf */
+/* adftype: 0=DD,1=HD,2=DD PC,3=HD PC,4=525SD */
+void disk_creatediskfile (const TCHAR *name, int type, drive_type adftype, const TCHAR *disk_name, bool ffs, bool bootable)
+{
+       int size = 32768;
+       struct zfile *f;
+       int i, l, file_size, tracks, track_len, sectors;
+       uae_u8 *chunk = NULL;
+       int ddhd = 1;
+
+       if (type == 1)
+               tracks = 2 * 83;
+       else
+               tracks = 2 * 80;
+       file_size = 880 * 1024;
+       sectors = 11;
+       if (adftype == 2 || adftype == 3) {
+               file_size = 720 * 1024;
+               sectors = 9;
+       }
+       track_len = FLOPPY_WRITE_LEN * 2;
+       if (adftype == 1 || adftype == 3) {
+               file_size *= 2;
+               track_len *= 2;
+               ddhd = 2;
+       } else if (adftype == 4) {
+               file_size /= 2;
+               tracks /= 2;
+       }
+
+       f = zfile_fopen (name, L"wb", 0);
+       chunk = xmalloc (uae_u8, size);
+       if (f && chunk) {
+               int cylsize = sectors * 2 * 512;
+               memset (chunk, 0, size);
+               if (type == 0) {
+                       for (i = 0; i < file_size; i += cylsize) {
+                               memset(chunk, 0, cylsize);
+                               if (adftype <= 1) {
+                                       if (i == 0) {
+                                               /* boot block */
+                                               floppy_get_bootblock (chunk, ffs, bootable);
+                                       } else if (i == file_size / 2) {
+                                               /* root block */
+                                               floppy_get_rootblock (chunk, file_size / 1024, disk_name, adftype);
+                                       }
+                               }
+                               zfile_fwrite (chunk, cylsize, 1, f);
+                       }
+               } else {
+                       uae_u8 root[4];
+                       uae_u8 rawtrack[3 * 4], dostrack[3 * 4];
+                       l = track_len;
+                       zfile_fwrite ("UAE-1ADF", 8, 1, f);
+                       root[0] = 0; root[1] = 0; /* flags (reserved) */
+                       root[2] = 0; root[3] = tracks; /* number of tracks */
+                       zfile_fwrite (root, 4, 1, f);
+                       rawtrack[0] = 0; rawtrack[1] = 0; /* flags (reserved) */
+                       rawtrack[2] = 0; rawtrack[3] = 1; /* track type */
+                       rawtrack[4] = 0; rawtrack[5] = 0; rawtrack[6]=(uae_u8)(l >> 8); rawtrack[7] = (uae_u8)l;
+                       rawtrack[8] = 0; rawtrack[9] = 0; rawtrack[10] = 0; rawtrack[11] = 0;
+                       memcpy (dostrack, rawtrack, sizeof rawtrack);
+                       dostrack[3] = 0;
+                       dostrack[9] = (l * 8) >> 16; dostrack[10] = (l * 8) >> 8; dostrack[11] = (l * 8) >> 0;
+                       bool dodos = ffs || bootable || (disk_name && _tcslen (disk_name) > 0);
+                       for (i = 0; i < tracks; i++) {
+                               uae_u8 tmp[3 * 4];
+                               memcpy (tmp, rawtrack, sizeof rawtrack);
+                               if (dodos)
+                                       memcpy (tmp, dostrack, sizeof dostrack);
+                               zfile_fwrite (tmp, sizeof tmp, 1, f);
+                       }
+                       for (i = 0; i < tracks; i++) {
+                               memset (chunk, 0, size);
+                               if (dodos) {
+                                       if (i == 0)
+                                               floppy_get_bootblock (chunk, ffs, bootable);
+                                       else if (i == 80)
+                                               floppy_get_rootblock (chunk, 80 * 11 * ddhd, disk_name, adftype);
+                               }
+                               zfile_fwrite (chunk, l, 1, f);
+                       }
+               }
+       }
+       xfree (chunk);
+       zfile_fclose (f);
+       if (f)
+               DISK_history_add (name, -1, HISTORY_FLOPPY, TRUE);
+
+}
+
+int disk_getwriteprotect (const TCHAR *name)
+{
+       int needwritefile;
+       drive_type drvtype;
+       return diskfile_iswriteprotect (name, &needwritefile, &drvtype);
+}
+
+static void diskfile_readonly (const TCHAR *name, bool readonly)
+{
+       struct _stat64 st;
+       int mode, oldmode;
+
+       if (stat (name, &st))
+               return;
+       oldmode = mode = st.st_mode;
+       mode &= ~FILEFLAG_WRITE;
+       if (!readonly)
+               mode |= FILEFLAG_WRITE;
+       if (mode != oldmode)
+               chmod (name, mode);
+}
+
+static void setdskchangetime (drive *drv, int dsktime)
+{
+       int i;
+       /* prevent multiple disk insertions at the same time */
+       if (drv->dskchange_time > 0)
+               return;
+       for (i = 0; i < MAX_FLOPPY_DRIVES; i++) {
+               if (&floppy[i] != drv && floppy[i].dskchange_time > 0 && floppy[i].dskchange_time + 1 >= dsktime) {
+                       dsktime = floppy[i].dskchange_time + 1;
+               }
+       }
+       drv->dskchange_time = dsktime;
+       if (disk_debug_logging > 0)
+               write_log (L"delayed insert enable %d\n", dsktime);
+}
+
+void DISK_reinsert (int num)
+{
+       drive_eject (&floppy[num]);
+       setdskchangetime (&floppy[num], 100);
+}
+
+int disk_setwriteprotect (int num, const TCHAR *name, bool writeprotected)
+{
+       int needwritefile, oldprotect;
+       struct zfile *zf1, *zf2;
+       bool wrprot1, wrprot2;
+       int i;
+       TCHAR *name2;
+       drive_type drvtype;
+
+       oldprotect = diskfile_iswriteprotect (name, &needwritefile, &drvtype);
+       DISK_validate_filename (name, 1, &wrprot1, NULL, &zf1);
+       if (!zf1)
+               return 0;
+       if (zfile_iscompressed (zf1))
+               wrprot1 = 1;
+       zfile_fclose (zf1);
+       zf2 = getwritefile (name, &wrprot2);
+       name2 = DISK_get_saveimagepath (name);
+
+       if (needwritefile && zf2 == 0)
+               disk_creatediskfile (name2, 1, drvtype, NULL, false, false);
+       zfile_fclose (zf2);
+       if (writeprotected && iswritefileempty (name)) {
+               for (i = 0; i < MAX_FLOPPY_DRIVES; i++) {
+                       if (!_tcscmp (name, floppy[i].newname))
+                               drive_eject (&floppy[i]);
+               }
+               _wunlink (name2);
+       }
+
+       if (!needwritefile)
+               diskfile_readonly (name, writeprotected);
+       diskfile_readonly (name2, writeprotected);
+       DISK_reinsert (num);
+       return 1;
+}
+
+void disk_eject (int num)
+{
+       config_changed = 1;
+       gui_filename (num, L"");
+       drive_eject (floppy + num);
+       *currprefs.floppyslots[num].df = *changed_prefs.floppyslots[num].df = 0;
+       floppy[num].newname[0] = 0;
+       update_drive_gui (num);
+}
+
+int DISK_history_add (const TCHAR *name, int idx, int type, int donotcheck)
+{
+       int i;
+
+       if (idx >= MAX_PREVIOUS_FLOPPIES)
+               return 0;
+       if (name == NULL) {
+               dfxhistory[type][idx][0] = 0;
+               return 1;
+       }
+       if (name[0] == 0)
+               return 0;
+       if (!donotcheck) {
+               if (!zfile_exists (name)) {
+                       for (i = 0; i < MAX_PREVIOUS_FLOPPIES; i++) {
+                               if (!_tcsicmp (dfxhistory[type][i], name)) {
+                                       while (i < MAX_PREVIOUS_FLOPPIES - 1) {
+                                               _tcscpy (dfxhistory[type][i], dfxhistory[type][i + 1]);
+                                               i++;
+                                       }
+                                       dfxhistory[type][MAX_PREVIOUS_FLOPPIES - 1][0] = 0;
+                                       break;
+                               }
+                       }
+                       return 0;
+               }
+       }
+       if (idx >= 0) {
+               if (idx >= MAX_PREVIOUS_FLOPPIES)
+                       return 0;
+               dfxhistory[type][idx][0] = 0;
+               for (i = 0; i < MAX_PREVIOUS_FLOPPIES; i++) {
+                       if (!_tcsicmp (dfxhistory[type][i], name))
+                               return 0;
+               }
+               _tcscpy (dfxhistory[type][idx], name);
+               return 1;
+       }
+       for (i = 0; i < MAX_PREVIOUS_FLOPPIES; i++) {
+               if (!_tcscmp (dfxhistory[type][i], name)) {
+                       while (i < MAX_PREVIOUS_FLOPPIES - 1) {
+                               _tcscpy (dfxhistory[type][i], dfxhistory[type][i + 1]);
+                               i++;
+                       }
+                       dfxhistory[type][MAX_PREVIOUS_FLOPPIES - 1][0] = 0;
+                       break;
+               }
+       }
+       for (i = MAX_PREVIOUS_FLOPPIES - 2; i >= 0; i--)
+               _tcscpy (dfxhistory[type][i + 1], dfxhistory[type][i]);
+       _tcscpy (dfxhistory[type][0], name);
+       return 1;
+}
+
+TCHAR *DISK_history_get (int idx, int type)
+{
+       if (idx >= MAX_PREVIOUS_FLOPPIES)
+               return NULL;
+       return dfxhistory[type][idx];
+}
+
+static void disk_insert_2 (int num, const TCHAR *name, int forced)
+{
+       drive *drv = floppy + num;
+
+       if (forced) {
+               drive_insert (drv, &currprefs, num, name, false);
+               return;
+       }
+       if (!_tcscmp (currprefs.floppyslots[num].df, name))
+               return;
+       _tcscpy (drv->newname, name);
+       _tcscpy (currprefs.floppyslots[num].df, name);
+       DISK_history_add (name, -1, HISTORY_FLOPPY, 0);
+       if (name[0] == 0) {
+               disk_eject (num);
+       } else if (!drive_empty(drv) || drv->dskchange_time > 0) {
+               drive_eject (drv);
+               /* set dskchange_time, disk_insert() will be
+               * called from DISK_check_change() after 2 second delay
+               * this makes sure that all programs detect disk change correctly
+               */
+               setdskchangetime (drv, 100);
+       } else {
+               setdskchangetime (drv, 1);
+       }
+}
+
+void disk_insert (int num, const TCHAR *name)
+{
+       config_changed = 1;
+       target_addtorecent (name, 0);
+       disk_insert_2 (num, name, 0);
+}
+void disk_insert_force (int num, const TCHAR *name, bool writeprotected)
+{
+       disk_insert_2 (num, name, 1);
+}
+
+static void DISK_check_change (void)
+{
+       if (currprefs.floppy_speed != changed_prefs.floppy_speed)
+               currprefs.floppy_speed = changed_prefs.floppy_speed;
+       for (int i = 0; i < MAX_FLOPPY_DRIVES; i++) {
+               drive *drv = floppy + i;
+               if (currprefs.floppyslots[i].dfxtype != changed_prefs.floppyslots[i].dfxtype) {
+                       currprefs.floppyslots[i].dfxtype = changed_prefs.floppyslots[i].dfxtype;
+                       reset_drive (i);
+#ifdef RETROPLATFORM
+                       rp_floppy_device_enable (i, currprefs.floppyslots[i].dfxtype >= 0);
+#endif
+               }
+       }
+}
+
+void DISK_vsync (void)
+{
+       DISK_check_change ();
+       for (int i = 0; i < MAX_FLOPPY_DRIVES; i++) {
+               drive *drv = floppy + i;
+               if (drv->dskchange_time == 0 && _tcscmp (currprefs.floppyslots[i].df, changed_prefs.floppyslots[i].df))
+                       disk_insert (i, changed_prefs.floppyslots[i].df);
+               if (drv->dskready_down_time > 0)
+                       drv->dskready_down_time--;
+               /* emulate drive motor turn on time */
+               if (drv->dskready_up_time > 0 && !drive_empty (drv)) {
+                       drv->dskready_up_time--;
+                       if (drv->dskready_up_time == 0 && !drv->motoroff)
+                               drv->dskready = true;
+               }
+               /* delay until new disk image is inserted */
+               if (drv->dskchange_time) {
+                       drv->dskchange_time--;
+                       if (drv->dskchange_time == 0) {
+                               drive_insert (drv, &currprefs, i, drv->newname, false);
+                               if (disk_debug_logging > 0)
+                                       write_log (L"delayed insert, drive %d, image '%s'\n", i, drv->newname);
+                               update_drive_gui (i);
+                       }
+               }
+       }
+}
+
+int disk_empty (int num)
+{
+       return drive_empty (floppy + num);
+}
+
+static TCHAR *tobin (uae_u8 v)
+{
+       int i;
+       static TCHAR buf[10];
+       for( i = 7; i >= 0; i--)
+               buf[7 - i] = v & (1 << i) ? '1' : '0';
+       buf[i] = 0;
+       return buf;
+}
+
+void DISK_select_set (uae_u8 data)
+{
+       prev_data = data;
+       prev_step = 0;
+}
+
+void DISK_select (uae_u8 data)
+{
+       int step_pulse, prev_selected, dr;
+
+       prev_selected = selected;
+
+       selected = (data >> 3) & 15;
+       side = 1 - ((data >> 2) & 1);
+       direction = (data >> 1) & 1;
+       step_pulse = data & 1;
+
+       if (disk_debug_logging > 1)
+               write_log (L"%08X %02X->%02X %s drvmask=%x", M68K_GETPC, prev_data, data, tobin(data), selected ^ 15);
+
+#ifdef AMAX
+       if (currprefs.amaxromfile[0])
+               amax_disk_select (data, prev_data);
+#endif
+
+       if ((prev_data & 0x80) != (data & 0x80)) {
+               for (dr = 0; dr < 4; dr++) {
+                       if (floppy[dr].indexhackmode > 1 && !(selected & (1 << dr))) {
+                               floppy[dr].indexhack = 1;
+                               if (disk_debug_logging > 1)
+                                       write_log (L" indexhack!");
+                       }
+               }
+       }
+
+       if (disk_debug_logging > 1) {
+               write_log (L" %d%d%d%d% ", (selected & 1) ? 0 : 1, (selected & 2) ? 0 : 1, (selected & 4) ? 0 : 1, (selected & 8) ? 0 : 1);
+               if ((prev_data & 0x80) != (data & 0x80))
+                       write_log (L" dskmotor %d ", (data & 0x80) ? 1 : 0);
+               if ((prev_data & 0x02) != (data & 0x02))
+                       write_log (L" direct %d ", (data & 0x02) ? 1 : 0);
+               if ((prev_data & 0x04) != (data & 0x04))
+                       write_log (L" side %d ", (data & 0x04) ? 1 : 0);
+       }
+
+       // step goes high and drive was selected when step pulse changes: step
+       if (prev_step != step_pulse) {
+               if (disk_debug_logging > 1)
+                       write_log (L" dskstep %d ", step_pulse);
+               prev_step = step_pulse;
+               if (prev_step && !savestate_state) {
+                       for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+                               if (!((prev_selected | disabled) & (1 << dr))) {
+                                       drive_step (floppy + dr, direction);
+                                       if (floppy[dr].indexhackmode > 1 && (data & 0x80))
+                                               floppy[dr].indexhack = 1;
+                               }
+                       }
+               }
+       }
+
+       if (!savestate_state) {
+               for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+                       drive *drv = floppy + dr;
+                       /* motor on/off workings tested with small assembler code on real Amiga 1200. */
+                       /* motor/id flipflop is set only when drive select goes from high to low */
+                       if (!(selected & (1 << dr)) && (prev_selected & (1 << dr)) ) {
+                               drv->drive_id_scnt++;
+                               drv->drive_id_scnt &= 31;
+                               drv->idbit = (drv->drive_id & (1L << (31 - drv->drive_id_scnt))) ? 1 : 0;
+                               if (!(disabled & (1 << dr))) {
+                                       if ((prev_data & 0x80) == 0 || (data & 0x80) == 0) {
+                                               /* motor off: if motor bit = 0 in prevdata or data -> turn motor on */
+                                               drive_motor (drv, 0);
+                                       } else if (prev_data & 0x80) {
+                                               /* motor on: if motor bit = 1 in prevdata only (motor flag state in data has no effect)
+                                               -> turn motor off */
+                                               drive_motor (drv, 1);
+                                       }
+                               }
+                               if (!currprefs.cs_df0idhw && dr == 0)
+                                       drv->idbit = 0;
+#ifdef DEBUG_DRIVE_ID
+                               write_log (L"DISK_status: sel %d id %s (%08X) [0x%08lx, bit #%02d: %d]\n",
+                                       dr, drive_id_name(drv), drv->drive_id, drv->drive_id << drv->drive_id_scnt, 31 - drv->drive_id_scnt, drv->idbit);
+#endif
+                       }
+               }
+       }
+
+       for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+               floppy[dr].state = (!(selected & (1 << dr))) | !floppy[dr].motoroff;
+               update_drive_gui (dr);
+       }
+       prev_data = data;
+       if (disk_debug_logging > 1)
+               write_log (L"\n");
+}
+
+uae_u8 DISK_status (void)
+{
+       uae_u8 st = 0x3c;
+       int dr;
+
+       for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+               drive *drv = floppy + dr;
+               if (drv->amax) {
+                       st = amax_disk_status ();
+               } else if (!((selected | disabled) & (1 << dr))) {
+                       if (drive_running (drv)) {
+                               if (drv->catweasel) {
+#ifdef CATWEASEL
+                                       if (catweasel_diskready (drv->catweasel))
+                                               st &= ~0x20;
+#endif
+                               } else {
+                                       if (drv->dskready && !drv->indexhack && currprefs.floppyslots[dr].dfxtype != DRV_35_DD_ESCOM)
+                                               st &= ~0x20;
+                               }
+                       } else {
+                               if (currprefs.cs_df0idhw || dr > 0) {
+                                       /* report drive ID */
+                                       if (drv->idbit && currprefs.floppyslots[dr].dfxtype != DRV_35_DD_ESCOM)
+                                               st &= ~0x20;
+                               } else {
+                                       /* non-ID internal drive: mirror real dskready */
+                                       if (drv->dskready)
+                                               st &= ~0x20;
+                               }
+                               /* dskrdy needs some cycles after switching the motor off.. (Pro Tennis Tour) */
+                               if (!currprefs.cs_df0idhw && dr == 0 && drv->motordelay)
+                                       st &= ~0x20;
+                       }
+                       if (drive_track0 (drv))
+                               st &= ~0x10;
+                       if (drive_writeprotected (drv))
+                               st &= ~8;
+                       if (drv->catweasel) {
+#ifdef CATWEASEL
+                               if (catweasel_disk_changed (drv->catweasel))
+                                       st &= ~4;
+#endif
+                       } else if (drv->dskchange && currprefs.floppyslots[dr].dfxtype != DRV_525_SD) {
+                               st &= ~4;
+                       }
+               } else if (!(selected & (1 << dr))) {
+                       if (drv->idbit)
+                               st &= ~0x20;
+               }
+       }
+       return st;
+}
+
+static bool unformatted (drive *drv)
+{
+       int tr = drv->cyl * 2 + side;
+       if (tr >= drv->num_tracks)
+               return true;
+       if (drv->filetype == ADF_EXT2 && drv->trackdata[tr].bitlen == 0 && drv->trackdata[tr].type != TRACK_AMIGADOS)
+               return true;
+       if (drv->trackdata[tr].type == TRACK_NONE)
+               return true;
+       return false;
+}
+
+/* get one bit from MFM bit stream */
+STATIC_INLINE uae_u32 getonebit (uae_u16 * mfmbuf, int mfmpos)
+{
+       uae_u16 *buf;
+
+       buf = &mfmbuf[mfmpos >> 4];
+       return (buf[0] & (1 << (15 - (mfmpos & 15)))) ? 1 : 0;
+}
+
+void dumpdisk (void)
+{
+       int i, j, k;
+       uae_u16 w;
+
+       for (i = 0; i < MAX_FLOPPY_DRIVES; i++) {
+               drive *drv = &floppy[i];
+               if (!(disabled & (1 << i))) {
+                       console_out_f (L"Drive %d: motor %s cylinder %2d sel %s %s mfmpos %d/%d\n",
+                               i, drv->motoroff ? L"off" : L" on", drv->cyl, (selected & (1 << i)) ? L"no" : L"yes",
+                               drive_writeprotected(drv) ? L"ro" : L"rw", drv->mfmpos, drv->tracklen);
+                       if (drv->motoroff == 0) {
+                               w = word;
+                               for (j = 0; j < 15; j++) {
+                                       console_out_f (L"%04X ", w);
+                                       for (k = 0; k < 16; k++) {
+                                               w <<= 1;
+                                               w |= getonebit (drv->bigmfmbuf, drv->mfmpos + j * 16 + k);
+                                       }
+                               }
+                               console_out (L"\n");
+                       }
+               }
+       }
+       console_out_f (L"side %d dma %d off %d word %04X pt %08X len %04X bytr %04X adk %04X sync %04X\n",
+               side, dskdmaen, bitoffset, word, dskpt, dsklen, dskbytr_val, adkcon, dsksync);
+}
+
+static void disk_dmafinished (void)
+{
+       INTREQ (0x8000 | 0x0002);
+       longwritemode = 0;
+       dskdmaen = 0;
+       if (disk_debug_logging > 0) {
+               int dr, mfmpos = -1;
+               write_log (L"disk dma finished %08X MFMpos=", dskpt);
+               for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++)
+                       write_log (L"%d%s", floppy[dr].mfmpos, dr < MAX_FLOPPY_DRIVES - 1 ? L"," : L"");
+               write_log (L"\n");
+       }
+}
+
+static void fetchnextrevolution (drive *drv)
+{
+       drv->trackspeed = get_floppy_speed2 (drv);
+       if (!drv->multi_revolution)
+               return;
+       switch (drv->filetype)
+       {
+       case ADF_IPF:
+#ifdef CAPS
+               caps_loadrevolution (drv->bigmfmbuf, drv - floppy, drv->cyl * 2 + side, &drv->tracklen);
+#endif
+               break;
+       case ADF_FDI:
+#ifdef FDI2RAW
+               fdi2raw_loadrevolution (drv->fdi, drv->bigmfmbuf, drv->tracktiming, drv->cyl * 2 + side, &drv->tracklen, 1);
+#endif
+               break;
+       }
+}
+void INTREQ_nodelay (uae_u16 v);
+
+void DISK_handler (uae_u32 data)
+{
+       int flag = data & 255;
+       int disk_sync_cycle = data >> 8;
+
+       DISK_update (disk_sync_cycle);
+       if (flag & (DISK_REVOLUTION << 0))
+               fetchnextrevolution (&floppy[0]);
+       if (flag & (DISK_REVOLUTION << 1))
+               fetchnextrevolution (&floppy[1]);
+       if (flag & (DISK_REVOLUTION << 2))
+               fetchnextrevolution (&floppy[2]);
+       if (flag & (DISK_REVOLUTION << 3))
+               fetchnextrevolution (&floppy[3]);
+       if (flag & DISK_WORDSYNC) {
+               INTREQ_nodelay (0x8000 | 0x1000);
+       }
+       if (flag & DISK_INDEXSYNC)
+               cia_diskindex ();
+}
+
+static void disk_doupdate_write (drive * drv, int endhpos)
+{
+       int dr;
+       int drives[4];
+
+       for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+               drive *drv2 = &floppy[dr];
+               drives[dr] = 0;
+               if (drv2->motoroff)
+                       continue;
+               if (selected & (1 << dr))
+                       continue;
+               drives[dr] = 1;
+       }
+
+       while (drv->floppybitcounter < endhpos) {
+               for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+                       if (drives[dr]) {
+                               floppy[dr].mfmpos++;
+                               floppy[dr].mfmpos %= drv->tracklen;
+                       }
+               }
+               if (dmaen (DMA_DISK) && dskdmaen == 3 && dsklength > 0 && (!(adkcon &0x400) || dma_enable) && fifo_filled) {
+                       bitoffset++;
+                       bitoffset &= 15;
+                       if (!bitoffset) {
+                               // fast disk modes, fill the fifo instantly
+                               if (currprefs.floppy_speed > 100 && !fifo_inuse[0] && !fifo_inuse[1] && !fifo_inuse[2]) {
+                                       while (!fifo_inuse[2]) {
+                                               uae_u16 w = chipmem_wget_indirect (dskpt);
+                                               DSKDAT (w);
+                                               dskpt += 2;
+                                       }
+                               }
+                               uae_u16 w = DSKDATR ();
+                               for (dr = 0; dr < MAX_FLOPPY_DRIVES ; dr++) {
+                                       drive *drv2 = &floppy[dr];
+                                       if (drives[dr]) {
+                                               drv2->bigmfmbuf[drv2->mfmpos >> 4] = w;
+                                               drv2->bigmfmbuf[(drv2->mfmpos >> 4) + 1] = 0x5555;
+                                               drv2->writtento = 1;
+                                       }
+#ifdef AMAX
+                                       if (currprefs.amaxromfile[0])
+                                               amax_diskwrite (w);
+#endif
+                               }
+                               dsklength--;
+                               if (dsklength <= 0) {
+                                       disk_dmafinished ();
+                                       for (int dr = 0; dr < MAX_FLOPPY_DRIVES ; dr++) {
+                                               drive *drv = &floppy[dr];
+                                               drv->writtento = 0;
+                                               if (drv->motoroff)
+                                                       continue;
+                                               if (selected & (1 << dr))
+                                                       continue;
+                                               drive_write_data (drv);
+                                       }
+                               }
+                       }
+               }
+               drv->floppybitcounter += drv->trackspeed;
+       }
+}
+
+static void update_jitter (void)
+{
+       if (currprefs.floppy_random_bits_max > 0)
+               disk_jitter = ((uaerand () >> 4) % (currprefs.floppy_random_bits_max - currprefs.floppy_random_bits_min + 1)) + currprefs.floppy_random_bits_min;
+       else
+               disk_jitter = 0;
+}
+
+static void updatetrackspeed (drive *drv, int mfmpos)
+{
+       if (dskdmaen < 3) {
+               int t = drv->tracktiming[mfmpos / 8];
+               drv->trackspeed = get_floppy_speed2 (drv) * t / 1000;
+               if (drv->trackspeed < 700 || drv->trackspeed > 3000) {
+                       static int warned;
+                       warned++;
+                       if (warned < 50)
+                               write_log (L"corrupted trackspeed value %d\n", drv->trackspeed);
+                       drv->trackspeed = 1000;
+               }
+       }
+}
+
+static void disk_doupdate_predict (int starthpos)
+{
+       int finaleventcycles = maxhpos << 8;
+       int finaleventflag = 0;
+       int oldmfmpos = 0, newmfmpos = 0;
+
+       for (int dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+               drive *drv = &floppy[dr];
+               if (drv->motoroff || !drv->trackspeed)
+                       continue;
+               if (selected & (1 << dr))
+                       continue;
+               int diskevent_flag = 0;
+               uae_u32 tword = word;
+               uae_u8 *debugptr = (uae_u8*)drv->bigmfmbuf + drv->mfmpos / 8;
+               int mfmpos = drv->mfmpos;
+               int indexhack = drv->indexhack;
+               int drhpos = drv->floppybitcounter - (drv->trackspeed - (drv->floppybitcounter % drv->trackspeed)) + drv->trackspeed;
+               while (!diskevent_flag && drhpos < ((maxhpos + 1) << 8)) {
+                       if (drv->tracktiming[0])
+                               updatetrackspeed (drv, mfmpos);
+                       if (dskdmaen != 3) {
+                               tword <<= 1;
+                               if (!drive_empty (drv)) {
+                                       if (unformatted (drv))
+                                               tword |= (uaerand () & 0x1000) ? 1 : 0;
+                                       else
+                                               tword |= getonebit (drv->bigmfmbuf, mfmpos);
+                               }
+                               if ((tword & 0xffff) == dsksync && dsksync != 0) {
+                                       uae_u8 *debugptr2 = (uae_u8*)drv->bigmfmbuf + mfmpos / 8;
+                                       diskevent_flag |= DISK_WORDSYNC;
+                               }
+                       }
+                       mfmpos++;
+                       mfmpos %= drv->tracklen;
+                       if (mfmpos == 0)
+                               diskevent_flag |= DISK_REVOLUTION << (drv - floppy);
+                       if (mfmpos == drv->indexoffset) {
+                               diskevent_flag |= DISK_INDEXSYNC;
+                               indexhack = 0;
+                       }
+                       if (dskdmaen != 3 && mfmpos == drv->skipoffset) {
+                               update_jitter ();
+                               int skipcnt = disk_jitter;
+                               while (skipcnt-- > 0) {
+                                       mfmpos++;
+                                       mfmpos %= drv->tracklen;
+                                       if (mfmpos == 0)
+                                               diskevent_flag |= DISK_REVOLUTION << (drv - floppy);
+                                       if (mfmpos == drv->indexoffset) {
+                                               diskevent_flag |= DISK_INDEXSYNC;
+                                               indexhack = 0;
+                                       }
+                               }
+                       }
+                       drhpos += drv->trackspeed;
+               }
+               if (drv->tracktiming[0])
+                       updatetrackspeed (drv, drv->mfmpos);
+               if (diskevent_flag && (drhpos >> 8) > (starthpos >> 8)) {
+                       finaleventcycles = drhpos;
+                       finaleventflag = diskevent_flag;
+                       oldmfmpos = drv->mfmpos;
+                       newmfmpos = mfmpos;
+               }
+       }
+       if (finaleventflag) {
+               write_log(L"%d %d %d %d %d %d\n", starthpos >> 8, finaleventcycles >> 8, (finaleventcycles - starthpos) >> 8, finaleventflag, oldmfmpos, newmfmpos);
+               event2_newevent (ev2_disk, (finaleventcycles - starthpos) >> 8, (finaleventcycles & ~0xff) | finaleventflag);
+       }
+}
+
+int disk_fifostatus (void)
+{
+       if (fifo_inuse[0] && fifo_inuse[1] && fifo_inuse[2])
+               return 1;
+       if (!fifo_inuse[0] && !fifo_inuse[1] && !fifo_inuse[2])
+               return -1;
+       return 0;
+}
+
+static bool doreaddma (void)
+{
+       if (dmaen (DMA_DISK) && bitoffset == 15 && dma_enable && dskdmaen == 2 && dsklength >= 0) {
+               if (dsklength > 0) {
+                       // fast disk modes, just flush the fifo
+                       if (currprefs.floppy_speed > 100 && fifo_inuse[0] && fifo_inuse[1] && fifo_inuse[2]) {
+                               while (fifo_inuse[0]) {
+                                       uae_u16 w = DSKDATR ();
+                                       chipmem_wput_indirect (dskpt, w);
+                                       dskpt += 2;
+                               }
+                       }
+                       DSKDAT (word);
+                       dsklength--;
+               } else if (dsklength == 0 && disk_fifostatus () < 0) {
+                       // zero length transfer wouldn't finish without this
+                       disk_dmafinished ();
+               }
+               return true;
+       }
+       return false;
+}
+
+static void disk_doupdate_read_nothing (int floppybits)
+{
+       int j = 0, k = 1, l = 0;
+
+       while (floppybits >= get_floppy_speed ()) {
+               word <<= 1;
+               doreaddma ();
+               if ((bitoffset & 7) == 7) {
+                       dskbytr_val = word & 0xff;
+                       dskbytr_val |= 0x8000;
+               }
+               bitoffset++;
+               bitoffset &= 15;
+               floppybits -= get_floppy_speed ();
+       }
+}
+
+static void disk_doupdate_read (drive * drv, int endhpos)
+{
+       int j = 0, k = 1, l = 0;
+
+       /*
+       uae_u16 *mfmbuf = drv->bigmfmbuf;
+       dsksync = 0x4444;
+       adkcon |= 0x400;
+       drv->mfmpos = 0;
+       memset (mfmbuf, 0, 1000);
+       cycles = 0x1000000;
+       // 4444 4444 4444 aaaa aaaaa 4444 4444 4444
+       // 4444 aaaa aaaa 4444
+       mfmbuf[0] = 0x4444;
+       mfmbuf[1] = 0x4444;
+       mfmbuf[2] = 0x4444;
+       mfmbuf[3] = 0xaaaa;
+       mfmbuf[4] = 0xaaaa;
+       mfmbuf[5] = 0x4444;
+       mfmbuf[6] = 0x4444;
+       mfmbuf[7] = 0x4444;
+       */
+       while (drv->floppybitcounter < endhpos) {
+               if (drv->tracktiming[0])
+                       updatetrackspeed (drv, drv->mfmpos);
+               word <<= 1;
+               if (!drive_empty (drv)) {
+                       if (unformatted (drv))
+                               word |= (uaerand () & 0x1000) ? 1 : 0;
+                       else
+                               word |= getonebit (drv->bigmfmbuf, drv->mfmpos);
+               }
+               //write_log (L"%08X bo=%d so=%d mfmpos=%d dma=%d\n", (word & 0xffffff), bitoffset, syncoffset, drv->mfmpos,dma_enable);
+               drv->mfmpos++;
+               drv->mfmpos %= drv->tracklen;
+               if (drv->mfmpos == drv->indexoffset) {
+                       if (disk_debug_logging > 1 && drv->indexhack)
+                               write_log (L"indexhack cleared\n");
+                       drv->indexhack = 0;
+               }
+               if (drv->mfmpos == drv->skipoffset) {
+                       update_jitter ();
+                       drv->mfmpos += disk_jitter;
+                       drv->mfmpos %= drv->tracklen;
+               }
+               doreaddma ();
+               if ((bitoffset & 7) == 7) {
+                       dskbytr_val = word & 0xff;
+                       dskbytr_val |= 0x8000;
+               }
+               if (word == dsksync) {
+                       dsksync_cycles = get_cycles () + WORDSYNC_TIME * CYCLE_UNIT;
+                       if (dskdmaen) {
+                               if (disk_debug_logging && dma_enable == 0)
+                                       write_log (L"Sync match, DMA started at %d PC=%08x\n", drv->mfmpos, M68K_GETPC);
+                               dma_enable = 1;
+                       }
+                       if (adkcon & 0x400)
+                               bitoffset = 15;
+               }
+               bitoffset++;
+               bitoffset &= 15;
+               drv->floppybitcounter += drv->trackspeed;
+       }
+}
+
+static void disk_dma_debugmsg (void)
+{
+       write_log (L"LEN=%04X (%d) SYNC=%04X PT=%08X ADKCON=%04X PC=%08X\n",
+               dsklength, dsklength, (adkcon & 0x400) ? dsksync : 0xffff, dskpt, adkcon, M68K_GETPC);
+}
+
+/* this is very unoptimized. DSKBYTR is used very rarely, so it should not matter. */
+
+uae_u16 DSKBYTR (int hpos)
+{
+       uae_u16 v;
+
+       DISK_update (hpos);
+       v = dskbytr_val;
+       dskbytr_val &= ~0x8000;
+       if (word == dsksync && cycles_in_range (dsksync_cycles))
+               v |= 0x1000;
+       if (dskdmaen && dmaen (DMA_DISK))
+               v |= 0x4000;
+       if (dsklen & 0x4000)
+               v |= 0x2000;
+       if (disk_debug_logging > 1)
+               write_log (L"DSKBYTR=%04X hpos=%d\n", v, hpos);
+       if (disk_debug_mode & DISK_DEBUG_PIO) {
+               int dr;
+               for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+                       drive *drv = &floppy[dr];
+                       if (drv->motoroff)
+                               continue;
+                       if (!(selected & (1 << dr))) {
+                               if (disk_debug_track < 0 || disk_debug_track == 2 * drv->cyl + side) {
+                                       disk_dma_debugmsg ();
+                                       write_log (L"DSKBYTR=%04X\n", v);
+                                       activate_debugger ();
+                                       break;
+                               }
+                       }
+               }
+       }
+       return v;
+}
+
+static void DISK_start (void)
+{
+       int dr;
+
+       for (int i = 0; i < 3; i++)
+               fifo_inuse[i] = false;
+       fifo_filled = 0;
+       for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+               drive *drv = &floppy[dr];
+               if (!(selected & (1 << dr))) {
+                       int tr = drv->cyl * 2 + side;
+                       trackid *ti = drv->trackdata + tr;
+
+                       if (dskdmaen == 3) {
+                               drv->tracklen = longwritemode ? FLOPPY_WRITE_MAXLEN : FLOPPY_WRITE_LEN * drv->ddhd * 8 * 2;
+                               drv->trackspeed = get_floppy_speed ();
+                               drv->skipoffset = -1;
+                               updatemfmpos (drv);
+                       }
+                       /* Ugh.  A nasty hack.  Assume ADF_EXT1 tracks are always read
+                       from the start.  */
+                       if (ti->type == TRACK_RAW1) {
+                               drv->mfmpos = 0;
+                               bitoffset = 0;
+                       }
+                       if (drv->catweasel)
+                               drive_fill_bigbuf (drv, 1);
+               }
+               drv->floppybitcounter = 0;
+       }
+}
+
+static int linecounter;
+
+void DISK_hsync (void)
+{
+       int dr;
+
+       for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+               drive *drv = &floppy[dr];
+               if (drv->steplimit)
+                       drv->steplimit--;
+       }
+       if (linecounter) {
+               linecounter--;
+               if (! linecounter)
+                       disk_dmafinished ();
+               return;
+       }
+       DISK_update (maxhpos);
+}
+
+void DISK_update (int tohpos)
+{
+       int dr;
+       int endhpos = tohpos << 8;
+
+       for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+               drive *drv = &floppy[dr];
+               if (drv->motoroff || !drv->tracklen || !drv->trackspeed)
+                       continue;
+               if (selected & (1 << dr)) {
+                       /* not selected but motor on: count mfmpos only */
+                       drv->mfmpos += (endhpos - drv->floppybitcounter) / drv->trackspeed;
+                       drv->mfmpos %= drv->tracklen;
+                       drv->floppybitcounter = endhpos;
+                       continue;
+               }
+               if (drv->diskfile)
+                       drive_fill_bigbuf (drv, 0);
+               drv->mfmpos %= drv->tracklen;
+       }
+       int didaccess = 0;
+       for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+               drive *drv = &floppy[dr];
+               if (drv->motoroff || !drv->trackspeed)
+                       continue;
+               if (selected & (1 << dr))
+                       continue;
+               /* selected and motor on */
+               if (dskdmaen == 3)
+                       disk_doupdate_write (drv, endhpos);
+               else
+                       disk_doupdate_read (drv, endhpos);
+               didaccess = 1;
+       }
+
+       if (!didaccess && dskdmaen == 2) {
+               /* no drive selected but read dma on: read zeros */
+               disk_doupdate_read_nothing ((tohpos << 8) - disk_hpos);
+       }
+
+       if (tohpos >= maxhpos) {
+               disk_hpos = disk_hpos & 0xff;
+               for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+                       drive *drv = &floppy[dr];
+                       if (drv->floppybitcounter < 255)
+                               continue;
+                       drv->floppybitcounter -= maxhpos << 8;
+                       if (drv->floppybitcounter < 0)
+                               drv->floppybitcounter = 0;
+               }
+               tohpos -= maxhpos;
+       } else {
+               disk_hpos = (disk_hpos & 0xff) | (tohpos << 8);
+       }
+
+       /* "predict" disk events from this point to end of scanline */
+       disk_doupdate_predict (tohpos << 8);
+
+}
+
+void DSKLEN (uae_u16 v, int hpos)
+{
+       int dr, prev = dsklen;
+       int noselected = 0;
+       int motormask;
+
+       DISK_update (hpos);
+
+       if ((v & 0x8000) && (dsklen & 0x8000)) {
+               dskdmaen = 2;
+               DISK_start ();
+               if (!(v & 0x4000))
+                       dma_enable = (adkcon & 0x400) ? 0 : 1;
+       }
+       if (!(v & 0x8000)) {
+               if (dskdmaen) {
+                       /* Megalomania and Knightmare does this */
+                       if (disk_debug_logging > 0 && dskdmaen == 2)
+                               write_log (L"warning: Disk read DMA aborted, %d words left PC=%x\n", dsklength, M68K_GETPC);
+                       if (dskdmaen == 3) {
+                               write_log (L"warning: Disk write DMA aborted, %d words left PC=%x\n", dsklength, M68K_GETPC);
+                               // did program write something that needs to be stored to file?
+                               for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+                                       drive *drv2 = &floppy[dr];
+                                       if (!drv2->writtento)
+                                               continue;
+                                       drive_write_data (drv2);
+                               }
+                       }
+                       dskdmaen = 0;
+               }
+       }
+       dsklen = v;
+       dsklength2 = dsklength = dsklen & 0x3fff;
+
+       if (dskdmaen == 0)
+               return;
+
+       if ((v & 0x4000) && (prev & 0x4000)) {
+               if (dsklength == 0)
+                       return;
+               if (dsklength == 1) {
+                       disk_dmafinished ();
+                       return;
+               }
+               dskdmaen = 3;
+               DISK_start ();
+       }
+
+       if (dsklength == 1)
+               dsklength = 0;
+
+       if (((disk_debug_mode & DISK_DEBUG_DMA_READ) && dskdmaen == 2) ||
+               ((disk_debug_mode & DISK_DEBUG_DMA_WRITE) && dskdmaen == 3))
+       {
+               for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+                       drive *drv = &floppy[dr];
+                       if (drv->motoroff)
+                               continue;
+                       if (!(selected & (1 << dr))) {
+                               if (disk_debug_track < 0 || disk_debug_track == 2 * drv->cyl + side) {
+                                       disk_dma_debugmsg ();
+                                       activate_debugger ();
+                                       break;
+                               }
+                       }
+               }
+       }
+
+       motormask = 0;
+       for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+               drive *drv = &floppy[dr];
+               drv->writtento = 0;
+               if (drv->motoroff)
+                       continue;
+               motormask |= 1 << dr;
+               if ((selected & (1 << dr)) == 0)
+                       break;
+       }
+       if (dr == 4) {
+               write_log (L"disk %s DMA started, drvmask=%x motormask=%x PC=%08x\n",
+                       dskdmaen == 3 ? L"write" : L"read", selected ^ 15, motormask, M68K_GETPC);
+               noselected = 1;
+       } else {
+               if (disk_debug_logging > 0) {
+                       write_log (L"disk %s DMA started, drvmask=%x track %d mfmpos %d dmaen=%d PC=%08X\n",
+                               dskdmaen == 3 ? L"write" : L"read", selected ^ 15,
+                               floppy[dr].cyl * 2 + side, floppy[dr].mfmpos, dma_enable, M68K_GETPC);
+                       disk_dma_debugmsg ();
+               }
+       }
+
+       for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++)
+               update_drive_gui (dr);
+
+       /* Try to make floppy access from Kickstart faster.  */
+       if (dskdmaen != 2 && dskdmaen != 3)
+               return;
+
+       for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+               drive *drv = &floppy[dr];
+               if (selected & (1 << dr))
+                       continue;
+               if (drv->filetype != ADF_NORMAL)
+                       break;
+       }
+       if (dr < MAX_FLOPPY_DRIVES) /* no turbo mode if any selected drive has non-standard ADF */
+               return;
+       {
+               int done = 0;
+               for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+                       drive *drv = &floppy[dr];
+                       int pos, i;
+
+                       if (drv->motoroff)
+                               continue;
+                       if (!drv->useturbo && currprefs.floppy_speed > 0)
+                               continue;
+                       if (selected & (1 << dr))
+                               continue;
+
+                       pos = drv->mfmpos & ~15;
+                       drive_fill_bigbuf (drv, 0);
+
+                       if (dskdmaen == 2) { /* TURBO read */
+
+                               if (adkcon & 0x400) {
+                                       for (i = 0; i < drv->tracklen; i += 16) {
+                                               pos += 16;
+                                               pos %= drv->tracklen;
+                                               if (drv->bigmfmbuf[pos >> 4] == dsksync) {
+                                                       /* must skip first disk sync marker */
+                                                       pos += 16;
+                                                       pos %= drv->tracklen;
+                                                       break;
+                                               }
+                                       }
+                                       if (i >= drv->tracklen)
+                                               return;
+                               }
+                               while (dsklength-- > 0) {
+                                       chipmem_wput_indirect (dskpt, drv->bigmfmbuf[pos >> 4]);
+                                       dskpt += 2;
+                                       pos += 16;
+                                       pos %= drv->tracklen;
+                               }
+                               INTREQ (0x8000 | 0x1000);
+                               done = 1;
+
+                       } else if (dskdmaen == 3) { /* TURBO write */
+
+                               for (i = 0; i < dsklength; i++) {
+                                       uae_u16 w = chipmem_wget_indirect (dskpt + i * 2);
+                                       drv->bigmfmbuf[pos >> 4] = w;
+#ifdef AMAX
+                                       if (currprefs.amaxromfile[0])
+                                               amax_diskwrite (w);
+#endif
+                                       pos += 16;
+                                       pos %= drv->tracklen;
+                               }
+                               drive_write_data (drv);
+                               done = 1;
+                       }
+               }
+               if (!done && noselected) {
+                       while (dsklength-- > 0) {
+                               if (dskdmaen == 3) {
+                                       uae_u16 w = chipmem_wget_indirect (dskpt);
+#ifdef AMAX
+                                       if (currprefs.amaxromfile[0])
+                                               amax_diskwrite (w);
+#endif
+                               } else {
+                                       chipmem_wput_indirect (dskpt, 0);
+                               }
+                               dskpt += 2;
+                       }
+                       INTREQ (0x8000 | 0x1000);
+                       done = 1;
+               }
+
+               if (done) {
+                       linecounter = 2;
+                       dskdmaen = 0;
+                       return;
+               }
+       }
+}
+
+void DISK_update_adkcon (int hpos, uae_u16 v)
+{
+       uae_u16 vold = adkcon;
+       uae_u16 vnew = adkcon;
+       if (v & 0x8000)
+                vnew |= v & 0x7FFF;
+       else
+               vnew &= ~v;
+       if ((vnew & 0x400) && !(vold & 0x400))
+               bitoffset = 0;
+}
+
+void DSKSYNC (int hpos, uae_u16 v)
+{
+       if (v == dsksync)
+               return;
+       DISK_update (hpos);
+       dsksync = v;
+}
+
+STATIC_INLINE bool iswrite (void)
+{
+       return dskdmaen == 3;
+}
+
+void DSKDAT (uae_u16 v)
+{
+       if (fifo_inuse[2]) {
+               write_log (L"DSKDAT: FIFO overflow!\n");
+               return;
+       }
+       fifo_inuse[2] = fifo_inuse[1];
+       fifo[2] = fifo[1];
+       fifo_inuse[1] = fifo_inuse[0];
+       fifo[1] = fifo[0];
+       fifo_inuse[0] = iswrite () ? 2 : 1;
+       fifo[0] = v;
+       fifo_filled = 1;
+}
+uae_u16 DSKDATR (void)
+{
+       int i;
+       uae_u16 v = 0;
+       for (i = 2; i >= 0; i--) {
+               if (fifo_inuse[i]) {
+                       fifo_inuse[i] = 0;
+                       v = fifo[i];
+                       break;
+               }
+       }
+       if (i < 0) {
+               write_log (L"DSKDATR: FIFO underflow!\n");
+       } else  if (dskdmaen > 0 && dskdmaen < 3 && dsklength <= 0 && disk_fifostatus () < 0) {
+               disk_dmafinished ();
+       }
+       return v;
+}
+
+uae_u16 disk_dmal (void)
+{
+       uae_u16 dmal = 0;
+       if (dskdmaen) {
+               if (dskdmaen == 3) {
+                       dmal = (1 + 2) * (fifo_inuse[0] ? 1 : 0) + (4 + 8) * (fifo_inuse[1] ? 1 : 0) + (16 + 32) * (fifo_inuse[2] ? 1 : 0);
+                       dmal ^= 63;
+                       if (dsklength == 2)
+                               dmal &= ~(16 + 32);
+                       if (dsklength == 1)
+                               dmal &= ~(16 + 32 + 4 + 8);
+               } else {
+                       dmal = 16 * (fifo_inuse[0] ? 1 : 0) + 4 * (fifo_inuse[1] ? 1 : 0) + 1 * (fifo_inuse[2] ? 1 : 0);
+               }
+       }
+       return dmal;
+}
+uaecptr disk_getpt (void)
+{
+       uaecptr pt = dskpt;
+       dskpt += 2;
+       return pt;
+}
+void DSKPTH (uae_u16 v)
+{
+       dskpt = (dskpt & 0xffff) | ((uae_u32) v << 16);
+}
+
+void DSKPTL (uae_u16 v)
+{
+       dskpt = (dskpt & ~0xffff) | (v);
+}
+
+void DISK_free (void)
+{
+       int dr;
+       for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+               drive *drv = &floppy[dr];
+               drive_image_free (drv);
+       }
+}
+
+void DISK_init (void)
+{
+       int dr;
+
+       for (dr = 0; dr < MAX_FLOPPY_DRIVES; dr++) {
+               drive *drv = &floppy[dr];
+               /* reset all drive types to 3.5 DD */
+               drive_settype_id (drv);
+               if (!drive_insert (drv, &currprefs, dr, currprefs.floppyslots[dr].df, false))
+                       disk_eject (dr);
+       }
+       if (disk_empty (0))
+               write_log (L"No disk in drive 0.\n");
+       amax_init ();
+}
+
+void DISK_reset (void)
+{
+       int i;
+
+       if (savestate_state)
+               return;
+
+       //floppy[0].catweasel = &cwc.drives[0];
+       disk_hpos = 0;
+       dskdmaen = 0;
+       disabled = 0;
+       for (i = 0; i < MAX_FLOPPY_DRIVES; i++)
+               reset_drive (i);
+       setamax ();
+}
+
+int DISK_examine_image (struct uae_prefs *p, int num, uae_u32 *crc32)
+{
+       int drvsec;
+       int ret, i;
+       drive *drv = &floppy[num];
+       uae_u32 dos, crc, crc2;
+       int wasdelayed = drv->dskchange_time;
+       int sectable[MAX_SECTORS];
+
+       ret = 0;
+       drv->cyl = 0;
+       side = 0;
+       *crc32 = 0;
+       if (!drive_insert (drv, p, num, p->floppyslots[num].df, true))
+               return 1;
+       if (!drv->diskfile)
+               return 1;
+       *crc32 = zfile_crc32 (drv->diskfile);
+       decode_buffer (drv->bigmfmbuf, drv->cyl, 11, drv->ddhd, drv->filetype, &drvsec, sectable, 1);
+       if (sectable[0] == 0 || sectable[1] == 0) {
+               ret = 2;
+               goto end;
+       }
+       crc = crc2 = 0;
+       for (i = 0; i < 1024; i += 4) {
+               uae_u32 v = (writebuffer[i] << 24) | (writebuffer[i + 1] << 16) | (writebuffer[i + 2] << 8) | writebuffer[i + 3];
+               if (i == 0)
+                       dos = v;
+               if (i == 4) {
+                       crc2 = v;
+                       v = 0;
+               }
+               if (crc + v < crc)
+                       crc++;
+               crc += v;
+       }
+       if (dos == 0x4b49434b) { /* KICK */
+               ret = 10;
+               goto end;
+       }
+       crc ^= 0xffffffff;
+       if (crc != crc2) {
+               ret = 3;
+               goto end;
+       }
+       if (dos == 0x444f5300)
+               ret = 10;
+       else if (dos == 0x444f5301 || dos == 0x444f5302 || dos == 0x444f5303)
+               ret = 11;
+       else if (dos == 0x444f5304 || dos == 0x444f5305 || dos == 0x444f5306 || dos == 0x444f5307)
+               ret = 12;
+       else
+               ret = 4;
+end:
+       drive_image_free (drv);
+       if (wasdelayed > 1) {
+               drive_eject (drv);
+               currprefs.floppyslots[num].df[0] = 0;
+               drv->dskchange_time = wasdelayed;
+               disk_insert (num, drv->newname);
+       }
+       return ret;
+}
+
+
+/* Disk save/restore code */
+
+#if defined SAVESTATE || defined DEBUGGER
+
+void DISK_save_custom (uae_u32 *pdskpt, uae_u16 *pdsklength, uae_u16 *pdsksync, uae_u16 *pdskbytr)
+{
+       if (pdskpt)
+               *pdskpt = dskpt;
+       if (pdsklength)
+               *pdsklength = dsklen;
+       if (pdsksync)
+               *pdsksync = dsksync;
+       if (pdskbytr)
+               *pdskbytr = dskbytr_val;
+}
+
+#endif /* SAVESTATE || DEBUGGER */
+
+static uae_u32 getadfcrc (drive *drv)
+{
+       uae_u8 *b;
+       uae_u32 crc32;
+       int size;
+
+       if (!drv->diskfile)
+               return 0;
+       zfile_fseek (drv->diskfile, 0, SEEK_END);
+       size = zfile_ftell (drv->diskfile);
+       b = xmalloc (uae_u8, size);
+       if (!b)
+               return 0;
+       zfile_fseek (drv->diskfile, 0, SEEK_SET);
+       zfile_fread (b, 1, size, drv->diskfile);
+       crc32 = get_crc32 (b, size);
+       free (b);
+       return crc32;
+}
+
+#ifdef SAVESTATE
+
+void DISK_restore_custom (uae_u32 pdskpt, uae_u16 pdsklength, uae_u16 pdskbytr)
+{
+       dskpt = pdskpt;
+       dsklen = pdsklength;
+       dskbytr_val = pdskbytr;
+}
+
+void restore_disk_finish (void)
+{
+       int cnt = 0;
+       for (int i = 0; i < MAX_FLOPPY_DRIVES; i++) {
+               if (currprefs.floppyslots[i].dfxtype >= 0)
+                       cnt++;
+       }
+       currprefs.nr_floppies = changed_prefs.nr_floppies = cnt;
+       DISK_check_change ();
+       setamax ();
+       if (dskdmaen)
+               dumpdisk ();
+}
+
+uae_u8 *restore_disk (int num,uae_u8 *src)
+{
+       drive *drv;
+       int state, dfxtype;
+       TCHAR old[MAX_DPATH];
+       TCHAR *s;
+       int newis;
+
+       drv = &floppy[num];
+       disabled &= ~(1 << num);
+       drv->drive_id = restore_u32 ();
+       drv->motoroff = 1;
+       drv->idbit = 0;
+       state = restore_u8 ();
+       if (state & 2) {
+               disabled |= 1 << num;
+               if (changed_prefs.nr_floppies > num)
+                       changed_prefs.nr_floppies = num;
+               changed_prefs.floppyslots[num].dfxtype = -1;
+       } else {
+               drv->motoroff = (state & 1) ? 0 : 1;
+               drv->idbit = (state & 4) ? 1 : 0;
+               switch (drv->drive_id)
+               {
+               case DRIVE_ID_35HD:
+                       dfxtype = DRV_35_HD;
+                       break;
+               case DRIVE_ID_525SD:
+                       dfxtype = DRV_525_SD;
+                       break;
+               default:
+                       dfxtype = DRV_35_DD;
+                       break;
+               }
+               currprefs.floppyslots[num].dfxtype = changed_prefs.floppyslots[num].dfxtype = dfxtype;
+       }
+       drv->dskchange = (state & 8) ? 1 : 0;
+       side = (state & 16) ? 1 : 0;
+       drv->indexhackmode = 0;
+       if (num == 0 && currprefs.floppyslots[num].dfxtype == 0)
+               drv->indexhackmode = 1;
+       drv->buffered_cyl = -1;
+       drv->buffered_side = -1;
+       drv->cyl = restore_u8 ();
+       drv->dskready = restore_u8 () != 0;
+       drv->drive_id_scnt = restore_u8 ();
+       int mfmpos = restore_u32 ();
+       drv->dskchange_time = 0;
+       restore_u32 ();
+       s = restore_path (SAVESTATE_PATH_FLOPPY);
+       _tcscpy (old, currprefs.floppyslots[num].df);
+       _tcsncpy (changed_prefs.floppyslots[num].df, s, 255);
+       xfree (s);
+       int dskready_up_time = restore_u16 ();
+       int dskready_down_time = restore_u16 ();
+       newis = changed_prefs.floppyslots[num].df[0] ? 1 : 0;
+       if (!(disabled & (1 << num))) {
+               if (!newis && old[0]) {
+                       *currprefs.floppyslots[num].df = *changed_prefs.floppyslots[num].df = 0;
+                       drv->dskchange = 0;
+               } else if (newis) {
+                       drive_insert (floppy + num, &currprefs, num, changed_prefs.floppyslots[num].df, false);
+                       if (drive_empty (floppy + num)) {
+                               if (newis && old[0]) {
+                                       _tcscpy (changed_prefs.floppyslots[num].df, old);
+                                       drive_insert (floppy + num, &currprefs, num, changed_prefs.floppyslots[num].df, false);
+                                       if (drive_empty (floppy + num))
+                                               drv->dskchange = 1;
+                               }
+                       }
+               }
+       }
+       drv->mfmpos = mfmpos;
+       drv->prevtracklen = drv->tracklen;
+       drv->dskready_up_time = dskready_up_time;
+       drv->dskready_down_time = dskready_down_time;
+       reset_drive_gui (num);
+       return src;
+}
+
+uae_u8 *restore_disk2 (int num,uae_u8 *src)
+{
+       drive *drv = &floppy[num];
+       uae_u32 m = restore_u32 ();
+       if (m) {
+               drv->floppybitcounter = restore_u16 ();
+               drv->tracklen = restore_u32 ();
+               drv->trackspeed = restore_u16 ();
+               drv->skipoffset = restore_u32 ();
+               drv->indexoffset = restore_u32 ();
+               drv->buffered_cyl = drv->cyl;
+               drv->buffered_side = side;
+               for (int j = 0; j < (drv->tracklen + 15) / 16; j++) {
+                       drv->bigmfmbuf[j] = restore_u16 ();
+                       if (m & 2)
+                               drv->tracktiming[j] = restore_u16 ();
+               }
+       }
+       return src;
+}
+
+uae_u8 *save_disk (int num, int *len, uae_u8 *dstptr, bool usepath)
+{
+       uae_u8 *dstbak,*dst;
+       drive *drv = &floppy[num];
+
+       if (dstptr)
+               dstbak = dst = dstptr;
+       else
+               dstbak = dst = xmalloc (uae_u8, 2 + 1 + 1 + 1 + 1 + 4 + 4 + 256);
+       save_u32 (drv->drive_id);           /* drive type ID */
+       save_u8 ((drv->motoroff ? 0 : 1) | ((disabled & (1 << num)) ? 2 : 0) | (drv->idbit ? 4 : 0) | (drv->dskchange ? 8 : 0) | (side ? 16 : 0));
+       save_u8 (drv->cyl);                             /* cylinder */
+       save_u8 (drv->dskready);            /* dskready */
+       save_u8 (drv->drive_id_scnt);   /* id mode position */
+       save_u32 (drv->mfmpos);                 /* disk position */
+       save_u32 (getadfcrc (drv));         /* CRC of disk image */
+       save_path (usepath ? currprefs.floppyslots[num].df : L"", SAVESTATE_PATH_FLOPPY);/* image name */
+       save_u16 (drv->dskready_up_time);
+       save_u16 (drv->dskready_down_time);
+       *len = dst - dstbak;
+       return dstbak;
+}
+
+uae_u8 *save_disk2 (int num, int *len, uae_u8 *dstptr)
+{
+       uae_u8 *dstbak,*dst;
+       drive *drv = &floppy[num];
+
+       int m = 0;
+       int size = 0;
+       if (drv->motoroff == 0 && drv->buffered_side >= 0 && drv->tracklen > 0) {
+               m = 1;
+               if (drv->tracktiming[0])
+                       m |= 2;
+               size += ((drv->tracklen + 15) * 2) / 8;
+       }
+       if (!m)
+               return NULL;
+
+       if (dstptr)
+               dstbak = dst = dstptr;
+       else
+               dstbak = dst = xmalloc (uae_u8, 2 + 4 + 2 + 4 + 4 + size);
+
+       save_u32 (m);
+       save_u16 (drv->floppybitcounter);
+       save_u32 (drv->tracklen);
+       save_u16 (drv->trackspeed);
+       save_u32 (drv->skipoffset);
+       save_u32 (drv->indexoffset);
+       for (int j = 0; j < (drv->tracklen + 15) / 16; j++) {
+               save_u16 (drv->bigmfmbuf[j]);
+               if (drv->tracktiming[0])
+                       save_u16 (drv->tracktiming[j]);
+       }
+
+       *len = dst - dstbak;
+       return dstbak;
+}
+
+/* internal floppy controller variables */
+
+uae_u8 *restore_floppy (uae_u8 *src)
+{
+       word = restore_u16 ();
+       bitoffset = restore_u8 ();
+       dma_enable = restore_u8 ();
+       disk_hpos = restore_u8 () & 0xff;
+       dskdmaen = restore_u8 ();
+       for (int i = 0; i < 3; i++) {
+               fifo[i] = restore_u16 ();
+               fifo_inuse[i] = restore_u8 ();
+               if (dskdmaen == 0)
+                       fifo_inuse[i] = false;
+       }
+       fifo_filled = fifo_inuse[0] || fifo_inuse[1] || fifo_inuse[2];
+       dsklength = restore_u16 ();
+       return src;
+}
+
+uae_u8 *save_floppy (int *len, uae_u8 *dstptr)
+{
+       uae_u8 *dstbak, *dst;
+
+       if (dstptr)
+               dstbak = dst = dstptr;
+       else
+               dstbak = dst = xmalloc (uae_u8, 100);
+
+       save_u16 (word);                        /* shift register */
+       save_u8 (bitoffset);            /* dma bit offset */
+       save_u8 (dma_enable);           /* disk sync found */
+       save_u8 (disk_hpos & 0xff);     /* next bit read position */
+       save_u8 (dskdmaen);                     /* dma status */
+       for (int i = 0; i < 3; i++) {
+               save_u16 (fifo[i]);
+               save_u8 (fifo_inuse[i]);
+       }
+       save_u16 (dsklength);
+       *len = dst - dstbak;
+       return dstbak;
+}
+
+#endif /* SAVESTATE */
+
+#define MAX_DISKENTRIES 4
+int disk_prevnext_name (TCHAR *imgp, int dir)
+{
+       TCHAR img[MAX_DPATH], *ext, *p, *p2, *ps, *dst[MAX_DISKENTRIES];
+       int num = -1;
+       int cnt, i;
+       TCHAR imgl[MAX_DPATH];
+       int ret, gotone, wrapped;
+       TCHAR *old;
+
+       old = my_strdup (imgp);
+
+       struct zfile *zf = zfile_fopen (imgp, L"rb", ZFD_NORMAL);
+       if (zf) {
+               _tcscpy (img, zfile_getname (zf));
+               zfile_fclose (zf);
+               zf = zfile_fopen (img, L"rb", ZFD_NORMAL);
+               if (!zf) // oops, no directory support in this archive type
+                       _tcscpy (img, imgp);
+               zfile_fclose (zf);
+       } else {
+               _tcscpy (img, imgp);
+       }
+
+       wrapped = 0;
+retry:
+       _tcscpy (imgl, img);
+       to_lower (imgl, sizeof imgl / sizeof (TCHAR));
+       gotone = 0;
+       ret = 0;
+       ps = imgl;
+       cnt = 0;
+       dst[cnt] = NULL;
+       for (;;) {
+               // disk x of y
+               p = _tcsstr (ps, L"(disk ");
+               if (p && _istdigit (p[6])) {
+                       p2 = p - imgl + img;
+                       num = _tstoi (p + 6);
+                       dst[cnt++] = p2 + 6;
+                       if (cnt >= MAX_DISKENTRIES - 1)
+                               break;
+                       gotone = 1;
+                       ps = p + 6;
+                       continue;
+               }
+               if (gotone)
+                        break;
+               p = _tcsstr (ps, L"disk");
+               if (p && _istdigit (p[4])) {
+                       p2 = p - imgl + img;
+                       num = _tstoi (p + 4);
+                       dst[cnt++] = p2 + 4;
+                       if (cnt >= MAX_DISKENTRIES - 1)
+                               break;
+                       gotone = 1;
+                       ps = p + 4;
+                       continue;
+               }
+               if (gotone)
+                        break;
+               ext = _tcsrchr (ps, '.');
+               if (!ext || ext - ps < 4)
+                       break;
+               TCHAR *ext2 = ext - imgl + img;
+               // name_<non numeric character>x.ext
+               if (ext[-3] == '_' && !_istdigit (ext[-2]) && _istdigit (ext[-1])) {
+                       num = _tstoi (ext - 1);
+                       dst[cnt++] = ext2 - 1;
+               // name_x.ext, name-x.ext, name x.ext
+               } else if ((ext[-2] == '_' || ext[-2] == '-' || ext[-2] == ' ') && _istdigit (ext[-1])) {
+                       num = _tstoi (ext - 1);
+                       dst[cnt++] = ext2 - 1;
+               // name_a.ext, name-a.ext, name a .ext
+               } else if ((ext[-2] == '_' || ext[-2] == '-' || ext[-2] == ' ') && ext[-1] >= 'a' && ext[-1] <= 'z') {
+                       num = ext[-1] - 'a' + 1;
+                       dst[cnt++] = ext2 - 1;
+               // nameA.ext
+               } else if (ext2[-2] >= 'a' && ext2[-2] <= 'z' && ext2[-1] >= 'A' && ext2[-1] <= 'Z') {
+                       num = ext[-1] - 'a' + 1;
+                       dst[cnt++] = ext2 - 1;
+               // namex.ext
+               } else if (!_istdigit (ext2[-2]) && _istdigit (ext[-1])) {
+                       num = ext[-1] - '0';
+                       dst[cnt++] = ext2 - 1;
+               }
+               break;
+       }
+       dst[cnt] = NULL;
+       if (num <= 0 || num >= 19)
+               goto end;
+       num += dir;
+       if (num > 9)
+               goto end;
+       if (num == 9)
+               num = 1;
+       else if (num == 0)
+               num = 9;
+       for (i = 0; i < cnt; i++) {
+               if (!_istdigit (dst[i][0])) {
+                       int capital = dst[i][0] >= 'A' && dst[i][0] <= 'Z';
+                       dst[i][0] = (num - 1) + (capital ? 'A' : 'a');
+               } else {
+                       dst[i][0] = num + '0';
+               }
+       }
+       if (zfile_exists (img)) {
+               ret = 1;
+               goto end;
+       }
+       if (gotone) { // was (disk x but no match, perhaps there are extra tags..
+               TCHAR *old2 = my_strdup (img);
+               for (;;) {
+                       ext = _tcsrchr (img, '.');
+                       if (!ext)
+                               break;
+                       if (ext == img)
+                               break;
+                       if (ext[-1] != ']')
+                               break;
+                       TCHAR *t = _tcsrchr (img, '[');
+                       if (!t)
+                               break;
+                       t[0] = 0;
+                       if (zfile_exists (img)) {
+                               ret = 1;
+                               goto end;
+                       }
+               }
+               _tcscpy (img, old2);
+               xfree (old2);
+       }
+       if (!wrapped) {
+               for (i = 0; i < cnt; i++) {
+                       if (!_istdigit (dst[i][0]))
+                               dst[i][0] = dst[i][0] >= 'A' && dst[i][0] <= 'Z' ? 'A' : 'a';
+                       else
+                               dst[i][0] = '1';
+                       if (dir < 0)
+                               dst[i][0] += 8;
+               }
+               wrapped++;
+       }
+       if (zfile_exists (img)) {
+               ret = -1;
+               goto end;
+       }
+       if (dir < 0 && wrapped < 2)
+               goto retry;
+       _tcscpy (img, old);
+
+end:
+       _tcscpy (imgp, img);
+       xfree (old);
+       return ret;
+}
+
+int disk_prevnext (int drive, int dir)
+{
+       TCHAR img[MAX_DPATH];
+
+        _tcscpy (img, currprefs.floppyslots[drive].df);
+
+       if (!img[0])
+               return 0;
+       disk_prevnext_name (img, dir);
+       _tcscpy (changed_prefs.floppyslots[drive].df, img);
+       return 1;
+}
+
+
+int getdebug(void)
+{
+       return floppy[0].mfmpos;
+}
\ No newline at end of file

diff --git a/fpp.cpp b/fpp.cpp
index 9c57244cd7e0f531a56763afdefba93d457c6366..c9465b52e6579ce054f151352480fc8f823d4c67 100644 (file)
--- a/fpp.cpp
+++ b/fpp.cpp
@@ -901,6 +901,9 @@ void fpuop_save (uae_u32 opcode)
                return;
        }
 
+//     if (regs.fpcr == 0 && regs.fpsr == 0 && regs.fpiar == 0 &&
+//             regs.fp[0] == 
+
        if (currprefs.fpu_model == 68060) {
                /* 12 byte 68060 IDLE frame.  */
                if (incr < 0) {

diff --git a/gayle.cpp b/gayle.cpp
index 41400ca53118ce771ddb396387074c3706785ac2..3714738c0e8924bcaa63426de24499a571a74930 100644 (file)
--- a/gayle.cpp
+++ b/gayle.cpp
@@ -1286,19 +1286,19 @@ static void mbres_write (uaecptr addr, uae_u32 val, int size)
 
        if (MBRES_LOG > 0)
                write_log (L"MBRES_WRITE %08X=%08X (%d) PC=%08X S=%d\n", addr, val, size, M68K_GETPC, regs.s);
-       if (regs.s) { /* CPU FC = supervisor only */
+       if (1 || regs.s) { /* CPU FC = supervisor only */
+               uae_u32 addr2 = addr & 3;
+               uae_u32 addr64 = (addr >> 6) & 3;
                if (addr == 0x1002)
                        garyidoffset = -1;
-               if (addr == 0x03)
+               if (addr64 == 0 && addr2 == 0x03)
                        ramsey_config = val;
-               if (addr == 0x02)
+               if (addr2 == 0x02)
                        gary_coldboot = (val & 0x80) ? 1 : 0;
-               if (addr == 0x01)
+               if (addr2 == 0x01)
                        gary_toenb = (val & 0x80) ? 1 : 0;
-               if (addr == 0x00)
+               if (addr2 == 0x00)
                        gary_timeout = (val & 0x80) ? 1 : 0;
-       } else {
-               custom_bank.wput (addr, val);
        }
 }
 
@@ -1307,35 +1307,47 @@ static uae_u32 mbres_read (uaecptr addr, int size)
        uae_u32 v = 0;
        addr &= 0xffff;
 
-       if (regs.s) { /* CPU FC = supervisor only */
+       if (1 || regs.s) { /* CPU FC = supervisor only (only newest ramsey/gary? never implemented?) */
+               uae_u32 addr2 = addr & 3;
+               uae_u32 addr64 = (addr >> 6) & 3;
                /* Gary ID (I don't think this exists in real chips..) */
                if (addr == 0x1002 && currprefs.cs_fatgaryrev >= 0) {
                        garyidoffset++;
                        garyidoffset &= 7;
                        v = (currprefs.cs_fatgaryrev << garyidoffset) & 0x80;
                }
-               if (addr == 0x43) { /* RAMSEY revision */
-                       if (currprefs.cs_ramseyrev >= 0)
-                               v = currprefs.cs_ramseyrev;
-               }
-               if (addr == 0x03) { /* RAMSEY config */
-                       if (currprefs.cs_ramseyrev >= 0)
-                               v = ramsey_config;
-               }
-               if (addr == 0x02) { /* coldreboot flag */
-                       if (currprefs.cs_fatgaryrev >= 0)
-                               v = gary_coldboot ? 0x80 : 0x00;
-               }
-               if (addr == 0x01) { /* toenb flag */
-                       if (currprefs.cs_fatgaryrev >= 0)
-                               v = gary_toenb ? 0x80 : 0x00;
-               }
-               if (addr == 0x00) { /* timeout flag */
-                       if (currprefs.cs_fatgaryrev >= 0)
-                               v = gary_timeout ? 0x80 : 0x00;
+               for (;;) {
+                       if (addr64 == 1 && addr2 == 0x03) { /* RAMSEY revision */
+                               if (currprefs.cs_ramseyrev >= 0)
+                                       v = currprefs.cs_ramseyrev;
+                               break;
+                       }
+                       if (addr64 == 0 && addr2 == 0x03) { /* RAMSEY config */
+                               if (currprefs.cs_ramseyrev >= 0)
+                                       v = ramsey_config;
+                               break;
+                       }
+                       if (addr2 == 0x03) {
+                               v = 0xff;
+                               break;
+                       }
+                       if (addr2 == 0x02) { /* coldreboot flag */
+                               if (currprefs.cs_fatgaryrev >= 0)
+                                       v = gary_coldboot ? 0x80 : 0x00;
+                       }
+                       if (addr2 == 0x01) { /* toenb flag */
+                               if (currprefs.cs_fatgaryrev >= 0)
+                                       v = gary_toenb ? 0x80 : 0x00;
+                       }
+                       if (addr2 == 0x00) { /* timeout flag */
+                               if (currprefs.cs_fatgaryrev >= 0)
+                                       v = gary_timeout ? 0x80 : 0x00;
+                       }
+                       v |= 0x7f;
+                       break;
                }
        } else {
-               v = custom_bank.wget (addr);
+               v = 0xff;
        }
        if (MBRES_LOG > 0)
                write_log (L"MBRES_READ %08X=%08X (%d) PC=%08X S=%d\n", addr, v, size, M68K_GETPC, regs.s);

diff --git a/gencpu.cpp b/gencpu.cpp
index fa2313f6780685ef304b29aacfee7f2e137d6d38..4a1d4a2ca906b9291b69edc6986f89499cb32f3e 100644 (file)
--- a/gencpu.cpp
+++ b/gencpu.cpp
@@ -50,6 +50,7 @@ static int optimized_flags;
 #define GF_PREFETCH 16
 #define GF_FC 32
 #define GF_MOVE 64
+#define GF_IR2IRC 128
 
 /* For the current opcode, the next lower level that will have different code.
 * Initialized to -1 for each opcode. If it remains unchanged, indicates we
@@ -120,6 +121,7 @@ static int need_endlabel;
 static int n_braces, limit_braces;
 static int m68k_pc_offset;
 static int insn_n_cycles, insn_n_cycles020;
+static int ir2irc;
 
 static void fpulimit (void)
 {
@@ -338,14 +340,23 @@ static const char *gen_nextibyte (int flags)
        return buffer;
 }
 
-static void irc2ir (void)
+static void irc2ir (bool dozero)
 {
        if (!using_prefetch)
                return;
+       if (ir2irc)
+               return;
+       ir2irc = 1;
        printf ("\tregs.ir = regs.irc;\n");
+       if (dozero)
+               printf ("\tregs.irc = 0;\n");
        if (using_ce)
                printf ("\tipl_fetch ();\n");
 }
+static void irc2ir (void)
+{
+       irc2ir (false);
+}
 
 static int did_prefetch;
 
@@ -355,6 +366,7 @@ static void fill_prefetch_2 (void)
                return;
        printf ("\t%s (%d);\n", prefetch_word, m68k_pc_offset + 2);
        did_prefetch = 1;
+       ir2irc = 0;
        count_read++;
        insn_n_cycles += 4;
 }
@@ -365,6 +377,7 @@ static void fill_prefetch_1 (int o)
                return;
        printf ("\t%s (%d);\n", prefetch_word, o);
        did_prefetch = 1;
+       ir2irc = 0;
        count_read++;
        insn_n_cycles += 4;
 }
@@ -382,6 +395,7 @@ static void fill_prefetch_0 (void)
                return;
        printf ("\t%s (0);\n", prefetch_word);
        did_prefetch = 1;
+       ir2irc = 0;
        count_read++;
        insn_n_cycles += 4;
 }
@@ -703,6 +717,8 @@ static void genamode2 (amodes mode, char *reg, wordsizes size, char *name, int g
 
        if (flags & GF_PREFETCH)
                fill_prefetch_next ();
+       else if (flags & GF_IR2IRC)
+               irc2ir (true);
 
        if (getv == 1) {
                start_brace ();
@@ -1431,7 +1447,8 @@ static void gen_opcode (unsigned long int opcode)
        struct instr *curi = table68k + opcode;
 
        insn_n_cycles = using_prefetch ? 0 : 4;
-
+       ir2irc = 0;
+       
        prefetch_long = NULL;
        srcli = NULL;
        srcbi = NULL;
@@ -1877,7 +1894,7 @@ static void gen_opcode (unsigned long int opcode)
                break;
        case i_BTST:
                genamode (curi->smode, "srcreg", curi->size, "src", 1, 0, 0);
-               genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0, 0);
+               genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0, GF_IR2IRC);
                fill_prefetch_next ();
                bsetcycles (curi);
                printf ("\tSET_ZFLG (1 ^ ((dst >> src) & 1));\n");
@@ -1886,7 +1903,7 @@ static void gen_opcode (unsigned long int opcode)
        case i_BCLR:
        case i_BSET:
                genamode (curi->smode, "srcreg", curi->size, "src", 1, 0, 0);
-               genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0, 0);
+               genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0, GF_IR2IRC);
                fill_prefetch_next ();
                bsetcycles (curi);
                // bclr needs 1 extra cycle

diff --git a/gfxutil.cpp b/gfxutil.cpp
index 8dad9023848b01aff10dc463d30e582e3dac143c..d94a5b6ce1563b9387f449db2149516e0adadaea 100644 (file)
--- a/gfxutil.cpp
+++ b/gfxutil.cpp
@@ -247,9 +247,7 @@ void alloc_colors_picasso (int rw, int gw, int bw, int rs, int gs, int bs, int r
                blue_shift = 11;
                break;
        case RGBFB_B5G5R5PC:
-               red_bits = 5;
-               green_bits = 5;
-               blue_bits = 5;
+               red_bits = green_bits = blue_bits = 5;
                red_shift = 0;
                green_shift = 5;
                blue_shift = 10;

diff --git a/hrtmon.rom.cpp b/hrtmon.rom.cpp
index af795950e6d7222ad55f2aa69d0569a706f67aa5..441fe954b152d26fe06a20bc8c0e0d49f9571e39 100644 (file)
--- a/hrtmon.rom.cpp
+++ b/hrtmon.rom.cpp
@@ -1,5203 +1,5218 @@
 unsigned char hrtrom[] = {
-       0x1f, 0x8b, 0x08, 0x00, 0x7e, 0x33, 0xad, 0x4a,
-       0x02, 0x01, 0xec, 0xbd, 0x0f, 0x7c, 0x54, 0xd5,
-       0x95, 0x38, 0x7e, 0xe6, 0x4f, 0x26, 0x93, 0x61,
-       0x08, 0x43, 0x88, 0x71, 0x44, 0x84, 0x47, 0x88,
-       0x71, 0x88, 0x21, 0x4c, 0xfe, 0x34, 0x46, 0x0c,
-       0x30, 0x33, 0xf9, 0xc3, 0x64, 0x08, 0x21, 0x4c,
-       0x02, 0x04, 0x44, 0x7d, 0x2f, 0x7f, 0xde, 0x4b,
-       0x20, 0x24, 0xd3, 0xc9, 0x04, 0x81, 0x66, 0x71,
-       0x40, 0x4b, 0x23, 0x75, 0x5d, 0xa4, 0xac, 0x65,
-       0x59, 0xbf, 0x7e, 0x85, 0xf5, 0xeb, 0x52, 0xeb,
-       0xd7, 0x8d, 0x94, 0x52, 0xb4, 0xac, 0x1d, 0x90,
-       0x52, 0x44, 0xaa, 0x91, 0xb2, 0x2e, 0x65, 0x59,
-       0x41, 0x8a, 0x1a, 0x28, 0xa5, 0x91, 0x52, 0x8a,
-       0x69, 0x64, 0x7e, 0xe7, 0xdc, 0xfb, 0xde, 0x64,
-       0x02, 0x68, 0xed, 0x76, 0xbf, 0xfb, 0xfd, 0xed,
-       0xe7, 0x6b, 0x60, 0xde, 0xb9, 0xe7, 0xdc, 0x73,
-       0xcf, 0xbd, 0xf7, 0xdc, 0x73, 0xcf, 0xbd, 0xf7,
-       0xbd, 0xfb, 0xee, 0x0b, 0x44, 0xab, 0x3a, 0xbd,
-       0xfe, 0xda, 0x89, 0x55, 0x5f, 0xaf, 0xea, 0x14,
-       0x21, 0x69, 0x37, 0x41, 0x60, 0x7f, 0xc9, 0x17,
-       0x39, 0x84, 0x51, 0x30, 0xec, 0xaf, 0xaa, 0x6c,
-       0x21, 0x26, 0x00, 0x3d, 0x08, 0xf0, 0x05, 0x7f,
-       0x19, 0x0b, 0xca, 0xfc, 0xd3, 0x04, 0x64, 0x5c,
-       0xde, 0xde, 0x96, 0xd3, 0x28, 0x85, 0x24, 0x21,
-       0x2f, 0x27, 0x3f, 0x4f, 0x70, 0xac, 0x5c, 0x99,
-       0x83, 0xff, 0xf3, 0x9c, 0xce, 0xc2, 0xc9, 0x16,
-       0x00, 0xef, 0xc7, 0x8f, 0x5c, 0x73, 0x0f, 0x44,
-       0xbb, 0xf2, 0x07, 0x61, 0x1c, 0x6c, 0x2f, 0x2b,
-       0xb7, 0xde, 0x0b, 0x3a, 0xd8, 0x06, 0x99, 0xb2,
-       0x19, 0x29, 0x69, 0x2a, 0x45, 0x1f, 0xa3, 0x14,
-       0x10, 0xa5, 0xa0, 0x18, 0x0a, 0x36, 0xaf, 0xa2,
-       0xd0, 0x81, 0x41, 0xa8, 0x4e, 0xd7, 0x1f, 0xdd,
-       0x0b, 0xdb, 0xe5, 0xae, 0x49, 0xfb, 0x60, 0xfb,
-       0xcc, 0x19, 0xec, 0xea, 0xe1, 0xb4, 0x15, 0x7b,
-       0x19, 0x56, 0xce, 0xb1, 0xf5, 0x83, 0x0c, 0xf3,
-       0xe5, 0xdd, 0x4b, 0x29, 0x17, 0xb9, 0xf3, 0x11,
-       0x2b, 0x2b, 0x9d, 0x74, 0x08, 0xb6, 0xe9, 0xfb,
-       0xe9, 0x9a, 0xb4, 0xd7, 0x77, 0x2f, 0xe6, 0x33,
-       0x79, 0xc1, 0xa7, 0xb0, 0xbd, 0x62, 0x0c, 0x0b,
-       0x4f, 0x50, 0x00, 0xae, 0xb1, 0xd0, 0x9d, 0x4a,
-       0xeb, 0xa4, 0x41, 0xf8, 0x75, 0x18, 0x60, 0xdb,
-       0x77, 0x9f, 0xf1, 0xbc, 0x8a, 0xd7, 0xe7, 0xb0,
-       0x34, 0x84, 0x3d, 0x9f, 0x3f, 0xa8, 0x23, 0xf8,
-       0x82, 0x0a, 0x77, 0xe4, 0x0f, 0xea, 0x09, 0xbe,
-       0x98, 0x3f, 0x68, 0x20, 0xf8, 0x52, 0xfe, 0xa0,
-       0x91, 0xe0, 0xcb, 0xf9, 0x83, 0x09, 0x04, 0x7b,
-       0xf2, 0x07, 0x4d, 0x04, 0x77, 0xe6, 0x0f, 0x26,
-       0x12, 0xdc, 0xa5, 0xc2, 0xdd, 0xf9, 0x83, 0xe5,
-       0x04, 0xf7, 0x88, 0x00, 0x1b, 0x86, 0x64, 0x83,
-       0x91, 0xcb, 0x66, 0x10, 0x65, 0x83, 0x99, 0xcb,
-       0x06, 0x2b, 0x97, 0x0d, 0x36, 0x2e, 0x1b, 0x52,
-       0xb9, 0x6c, 0xb0, 0x73, 0xd9, 0xa8, 0x4d, 0x26,
-       0x9b, 0xc1, 0xdd, 0x2a, 0xdc, 0x83, 0x75, 0x38,
-       0x21, 0xb0, 0x3a, 0x50, 0x68, 0x23, 0x85, 0x9e,
-       0x63, 0xf5, 0x13, 0xe4, 0x54, 0xa4, 0xfc, 0xbb,
-       0x20, 0xa8, 0x71, 0xff, 0xee, 0xa4, 0xd0, 0x73,
-       0x63, 0x06, 0xae, 0x19, 0x51, 0x67, 0x9b, 0x02,
-       0x60, 0x23, 0xae, 0x3b, 0x22, 0x98, 0x6f, 0xe5,
-       0x1f, 0x21, 0xd1, 0x9c, 0xea, 0xfd, 0x14, 0x12,
-       0x31, 0x26, 0x4f, 0x2a, 0xaa, 0x3c, 0xf5, 0xc8,
-       0xb5, 0x00, 0xa0, 0xcd, 0x6c, 0xb7, 0xf6, 0xc3,
-       0xf6, 0x91, 0x75, 0xf8, 0x8b, 0xc0, 0xf6, 0x11,
-       0x7b, 0x10, 0x17, 0xf0, 0xd7, 0x0d, 0xdb, 0x93,
-       0x1d, 0xf8, 0xdb, 0x88, 0xbf, 0xab, 0xb0, 0x7d,
-       0x94, 0x88, 0xbf, 0x43, 0xb0, 0xdd, 0xe6, 0x94,
-       0x60, 0xc4, 0xc5, 0xbf, 0x3b, 0x92, 0x8f, 0xbc,
-       0x33, 0x9d, 0x8a, 0xb1, 0x6a, 0xf5, 0x21, 0xdd,
-       0xa4, 0x23, 0xd8, 0x16, 0x67, 0x85, 0xca, 0x12,
-       0x6c, 0x81, 0x97, 0x97, 0x38, 0x8b, 0x21, 0x9a,
-       0x7e, 0x7c, 0xde, 0xa1, 0xe8, 0xa0, 0x66, 0x8f,
-       0x7f, 0xd9, 0x1f, 0xda, 0x35, 0xfb, 0x47, 0x61,
-       0xb2, 0x77, 0xf8, 0xea, 0xef, 0xab, 0xbf, 0xaf,
-       0xfe, 0xfe, 0x9f, 0xfd, 0x73, 0xd7, 0x2e, 0x9e,
-       0x88, 0x5e, 0xff, 0x00, 0x1f, 0xa1, 0xf8, 0xe0,
-       0x54, 0xbf, 0x4a, 0x70, 0xb7, 0x4a, 0x2d, 0x6d,
-       0xc2, 0x1c, 0xa9, 0xb5, 0x69, 0x99, 0xe0, 0xf0,
-       0xb6, 0x07, 0xdb, 0x9a, 0x42, 0x42, 0xbb, 0x8c,
-       0xe4, 0x06, 0x29, 0x14, 0x94, 0x56, 0x4f, 0x16,
-       0x70, 0x34, 0xc2, 0x51, 0x2b, 0x7a, 0x4d, 0x28,
-       0x4e, 0x29, 0x58, 0xb0, 0xd2, 0x87, 0xe3, 0xd0,
-       0x4c, 0xbf, 0x6c, 0xe9, 0x79, 0x15, 0xb6, 0xcf,
-       0xe8, 0xc1, 0xf1, 0xe2, 0xe8, 0xa4, 0x08, 0x85,
-       0x24, 0xf8, 0x34, 0xb3, 0x0a, 0xc7, 0x89, 0xee,
-       0x22, 0x1f, 0x5e, 0xa1, 0x58, 0x36, 0x11, 0xf6,
-       0xd7, 0x3d, 0xe8, 0x6d, 0xb7, 0xfb, 0xa6, 0x28,
-       0x16, 0xf4, 0xb1, 0xdb, 0x7d, 0xbb, 0xf1, 0x27,
-       0x3a, 0xef, 0x25, 0x0f, 0xd8, 0x5b, 0x0c, 0xce,
-       0x31, 0x98, 0xb2, 0x7c, 0x29, 0xf1, 0xfd, 0xe8,
-       0x92, 0x3a, 0xfe, 0x14, 0x08, 0xf7, 0x92, 0x1f,
-       0x56, 0x32, 0x33, 0x5d, 0xbe, 0x31, 0x4b, 0x85,
-       0xcc, 0x55, 0xe4, 0x9f, 0x55, 0x8f, 0x6d, 0x75,
-       0x52, 0xdc, 0x2e, 0x5b, 0x3e, 0x80, 0xc8, 0xa4,
-       0x6f, 0x59, 0x4f, 0xd7, 0xa7, 0x43, 0xe4, 0x3f,
-       0xbf, 0x5b, 0x9c, 0xdf, 0x55, 0xfa, 0x38, 0xac,
-       0xc9, 0xef, 0x02, 0x41, 0x77, 0x32, 0xbf, 0xcb,
-       0xb9, 0x16, 0x9e, 0xc4, 0xeb, 0x3e, 0xd8, 0x88,
-       0x94, 0x22, 0xd8, 0x84, 0xd7, 0x5e, 0xd8, 0x8c,
-       0x57, 0xd0, 0x99, 0xd9, 0xd5, 0xc2, 0xae, 0x26,
-       0x76, 0x1d, 0xcc, 0xef, 0xda, 0x84, 0xc3, 0x30,
-       0x0b, 0xeb, 0xd1, 0xbf, 0xd3, 0x0c, 0xe1, 0x63,
-       0x57, 0x84, 0xca, 0x82, 0x35, 0xc9, 0x10, 0x56,
-       0x82, 0x51, 0x30, 0x9f, 0xe9, 0x6e, 0x1a, 0x5b,
-       0xd2, 0x07, 0xe9, 0x01, 0x08, 0xde, 0xda, 0xbb,
-       0x68, 0xde, 0x9b, 0xd1, 0xc1, 0x72, 0x57, 0x4f,
-       0x33, 0xf8, 0x65, 0x63, 0x00, 0x44, 0x7d, 0x20,
-       0x5a, 0x79, 0xca, 0xa0, 0xaf, 0xea, 0x44, 0x7f,
-       0xbb, 0x2d, 0xa9, 0x5e, 0xfd, 0x3d, 0x79, 0xdd,
-       0xaf, 0xfe, 0x3f, 0xff, 0x77, 0x4b, 0xf0, 0x3a,
-       0x9a, 0xf8, 0x7f, 0x26, 0x9f, 0x2f, 0xff, 0xab,
-       0xea, 0x28, 0x1f, 0xbc, 0x0b, 0x26, 0xfd, 0x96,
-       0xcd, 0x62, 0xb2, 0xf3, 0xff, 0x15, 0xaf, 0x59,
-       0xf9, 0xbf, 0x05, 0x13, 0x42, 0x27, 0x1b, 0xe7,
-       0x4f, 0x7d, 0x62, 0xca, 0x1f, 0x1c, 0x45, 0x30,
-       0xcc, 0x79, 0xc9, 0x46, 0xca, 0x66, 0x2b, 0x87,
-       0x84, 0xb9, 0xd4, 0x92, 0xff, 0x9b, 0x46, 0xc2,
-       0x47, 0xf2, 0x8e, 0xbf, 0x32, 0x08, 0xcf, 0x9b,
-       0x96, 0xd4, 0x1e, 0x8a, 0x5e, 0xa9, 0x46, 0x6a,
-       0x59, 0xa5, 0x08, 0xb7, 0x4e, 0x8b, 0x8d, 0x65,
-       0x5d, 0x89, 0x60, 0xfe, 0x94, 0xe6, 0x0c, 0xe0,
-       0x50, 0xf4, 0x5c, 0x8a, 0xf7, 0xd3, 0x68, 0x14,
-       0x2d, 0x71, 0x97, 0x30, 0x15, 0xf4, 0x3d, 0x7b,
-       0x31, 0x06, 0x9a, 0xd2, 0x10, 0xa2, 0x8c, 0xc6,
-       0x64, 0x6c, 0x49, 0x8c, 0xf1, 0x50, 0x7b, 0x3a,
-       0xaa, 0x3a, 0xe6, 0x7e, 0x4a, 0x54, 0x09, 0x3e,
-       0xcb, 0x92, 0xb0, 0x61, 0xad, 0xab, 0x80, 0xc6,
-       0x7c, 0xe7, 0xf2, 0xa2, 0xaa, 0xd5, 0x60, 0x24,
-       0x6b, 0x9e, 0x39, 0x16, 0x43, 0x09, 0x2c, 0x34,
-       0x1e, 0x43, 0x26, 0x16, 0x4a, 0xc7, 0x50, 0x22,
-       0x0b, 0x65, 0x62, 0xc8, 0xc0, 0x42, 0x69, 0x97,
-       0xaf, 0x5e, 0x3e, 0xfe, 0x7b, 0xfb, 0x9c, 0x4f,
-       0xe1, 0x54, 0x3f, 0x4c, 0xba, 0xc8, 0xe4, 0x64,
-       0x9b, 0x73, 0xb0, 0xae, 0x7a, 0xf9, 0xaa, 0x80,
-       0x3d, 0x65, 0x46, 0x7f, 0x7e, 0x2f, 0x5e, 0x2f,
-       0x4f, 0xea, 0x43, 0x6d, 0x6c, 0x9f, 0x71, 0xc5,
-       0x7c, 0x2f, 0x24, 0xc0, 0x4f, 0x4e, 0xeb, 0xe4,
-       0xd4, 0xf4, 0x62, 0xea, 0x57, 0x35, 0x6b, 0x15,
-       0x8b, 0x33, 0x07, 0xc6, 0x47, 0xba, 0x40, 0xaf,
-       0x5c, 0xaa, 0x6a, 0xc6, 0x79, 0xd9, 0xf6, 0x19,
-       0xd7, 0x26, 0x7d, 0x4a, 0x29, 0xf1, 0x37, 0x40,
-       0x7d, 0x65, 0xc6, 0xe5, 0x48, 0x97, 0x00, 0xb2,
-       0x89, 0xc5, 0xf5, 0xe3, 0x5c, 0x6c, 0xfb, 0x4c,
-       0x3d, 0x96, 0x59, 0xc7, 0xca, 0x6c, 0xa9, 0x5a,
-       0x6d, 0xd6, 0xb1, 0xb2, 0x10, 0x4d, 0xcf, 0x68,
-       0x6d, 0x58, 0x3e, 0x3d, 0xa3, 0x99, 0x02, 0x80,
-       0x54, 0x13, 0x51, 0x65, 0xdb, 0xa4, 0x41, 0xcf,
-       0xfc, 0x1a, 0x3f, 0xf6, 0xb8, 0x85, 0x18, 0x6f,
-       0x16, 0x93, 0xb5, 0x7a, 0xb7, 0xe2, 0x5c, 0xc4,
-       0xcc, 0xf9, 0x2d, 0x2c, 0xe7, 0x01, 0x0c, 0x71,
-       0x8d, 0x0d, 0x68, 0xa9, 0x15, 0x13, 0xf2, 0x18,
-       0xc4, 0xe4, 0x49, 0x83, 0xd5, 0x25, 0xfe, 0xe9,
-       0x28, 0xa3, 0x18, 0x71, 0x33, 0x4b, 0x93, 0xc2,
-       0xfb, 0xbb, 0x92, 0x56, 0xb5, 0xba, 0x5b, 0x87,
-       0xf5, 0x6c, 0x85, 0x6d, 0x23, 0xb7, 0x4e, 0xec,
-       0x62, 0x96, 0xd9, 0x2a, 0x1a, 0x25, 0xd0, 0xaf,
-       0x96, 0xc0, 0xb0, 0x18, 0x35, 0xbd, 0x60, 0xd2,
-       0x60, 0x34, 0x4a, 0x6d, 0xe4, 0x1d, 0xa4, 0x16,
-       0xf7, 0xde, 0xa2, 0x34, 0x33, 0x6f, 0x52, 0xab,
-       0x24, 0x7b, 0x18, 0xf4, 0x30, 0xaa, 0xe8, 0xe7,
-       0xb5, 0xe6, 0xfa, 0xa3, 0xba, 0x2b, 0xb6, 0x25,
-       0xdd, 0x4e, 0x5b, 0x9f, 0xf7, 0xb4, 0xb7, 0x62,
-       0xa0, 0x7a, 0x46, 0xef, 0x65, 0x3d, 0x4c, 0x42,
-       0xad, 0xce, 0x6a, 0x14, 0xb0, 0x95, 0x47, 0x7c,
-       0xe4, 0xa0, 0xb4, 0xfa, 0xc9, 0x98, 0xe3, 0x88,
-       0x3e, 0xb0, 0xa9, 0x32, 0xd2, 0x7c, 0x83, 0x53,
-       0x57, 0x11, 0x0f, 0xe8, 0x45, 0xf8, 0xec, 0x28,
-       0x96, 0xa2, 0x08, 0x4b, 0xf0, 0x98, 0xb3, 0xf8,
-       0x91, 0xe8, 0x74, 0x17, 0x6c, 0xc5, 0xdf, 0xd3,
-       0xf8, 0x7b, 0x06, 0x69, 0x26, 0x2c, 0x9d, 0x4b,
-       0x82, 0xf4, 0x23, 0x9a, 0x4e, 0xdb, 0x85, 0x58,
-       0xad, 0xad, 0x54, 0x86, 0x99, 0x29, 0x55, 0xdf,
-       0xe8, 0x36, 0x88, 0x96, 0x58, 0xd8, 0xcc, 0x4a,
-       0x76, 0xad, 0x4a, 0xcc, 0x21, 0x38, 0x30, 0x83,
-       0x3c, 0xe1, 0x65, 0x5e, 0x0a, 0xb5, 0x3e, 0xa9,
-       0xb0, 0x30, 0x0c, 0x93, 0x2e, 0x40, 0x06, 0x96,
-       0xe5, 0xaa, 0x7b, 0xa0, 0xe6, 0xc9, 0xc9, 0x5e,
-       0xc8, 0xb0, 0xbe, 0xaa, 0xd5, 0xfe, 0x86, 0xf8,
-       0xad, 0x14, 0x4f, 0xe5, 0x9d, 0x71, 0x05, 0xf4,
-       0x12, 0xe8, 0x9e, 0x88, 0xb5, 0x1a, 0xcf, 0xd5,
-       0x52, 0xf5, 0x8d, 0xb0, 0x39, 0x56, 0xbe, 0xf1,
-       0xb1, 0x96, 0x8b, 0xc5, 0x76, 0xeb, 0xa9, 0xbd,
-       0x66, 0x9a, 0xaa, 0xbe, 0x01, 0xfa, 0x98, 0x3d,
-       0xe7, 0x30, 0xda, 0x58, 0xa4, 0x19, 0x59, 0x68,
-       0x3c, 0x86, 0x12, 0x58, 0x28, 0x1d, 0x43, 0x26,
-       0x16, 0xca, 0xc4, 0x50, 0x22, 0xb7, 0x62, 0xc2,
-       0xbf, 0xeb, 0x3a, 0xd3, 0x7d, 0xd1, 0x9b, 0x9e,
-       0x03, 0xc6, 0x33, 0x8f, 0x5f, 0xac, 0xd8, 0xe9,
-       0xa2, 0x76, 0x9a, 0x59, 0xa7, 0xa4, 0x7b, 0x18,
-       0x74, 0x7f, 0x0a, 0xc6, 0x30, 0x60, 0x1f, 0xc5,
-       0xbe, 0x25, 0x14, 0x83, 0xc1, 0xb4, 0xe4, 0xa3,
-       0x6e, 0xe1, 0x97, 0xc2, 0x2f, 0x71, 0xce, 0x3a,
-       0xc0, 0x38, 0x17, 0x2a, 0x29, 0x4c, 0x03, 0x4e,
-       0x25, 0x43, 0x58, 0xfd, 0xfb, 0x2e, 0x2c, 0x97,
-       0x4e, 0x1c, 0xab, 0xda, 0x47, 0x32, 0xd9, 0xc7,
-       0xc4, 0x55, 0x64, 0x1d, 0xdc, 0x2e, 0xa0, 0xbb,
-       0xf2, 0xd3, 0x47, 0xa2, 0xf1, 0xfd, 0x92, 0xf5,
-       0xee, 0x8f, 0xc3, 0x87, 0xb8, 0x2e, 0xdd, 0x43,
-       0xb3, 0xe2, 0xda, 0x1f, 0x0c, 0xb2, 0xfe, 0x6c,
-       0xf9, 0x01, 0xf3, 0x09, 0x8d, 0x7a, 0xc7, 0xc6,
-       0xba, 0xee, 0xba, 0x27, 0x30, 0xdf, 0x8f, 0xf8,
-       0xdc, 0x99, 0xe9, 0x41, 0x3f, 0x34, 0x83, 0xae,
-       0x3c, 0x35, 0x46, 0x47, 0x3e, 0x3c, 0x7a, 0x4d,
-       0x7a, 0x99, 0x97, 0x48, 0xb6, 0x4c, 0x1c, 0x54,
-       0x6d, 0xd2, 0xec, 0x1e, 0x18, 0x58, 0x42, 0x65,
-       0xe3, 0x9e, 0x3e, 0x16, 0x4f, 0x92, 0x0e, 0x61,
-       0x3c, 0xd7, 0xaa, 0x9e, 0x38, 0xaa, 0x3a, 0xa7,
-       0x82, 0xa6, 0xf7, 0x86, 0xac, 0x98, 0xde, 0xc7,
-       0x51, 0x0f, 0x43, 0xcc, 0xc0, 0x52, 0x1a, 0xc3,
-       0x5d, 0x66, 0x08, 0x77, 0x81, 0x99, 0xb4, 0x2f,
-       0x1a, 0x49, 0x9b, 0xc2, 0x04, 0xca, 0x7d, 0x56,
-       0x71, 0x00, 0x2a, 0xae, 0x82, 0x2d, 0x27, 0xb5,
-       0x6c, 0x00, 0xfc, 0x8e, 0x0d, 0x65, 0xa8, 0xb9,
-       0xe4, 0x48, 0xd5, 0x6a, 0xbb, 0x2e, 0xa0, 0x9b,
-       0x75, 0xd9, 0x0e, 0xd9, 0x63, 0x32, 0x37, 0xcf,
-       0xfe, 0x35, 0x8c, 0xcb, 0xba, 0x25, 0x6b, 0x33,
-       0x72, 0x64, 0x54, 0xad, 0xb6, 0xe9, 0x03, 0x7a,
-       0x0c, 0x59, 0xfa, 0xa7, 0x5a, 0x20, 0x3a, 0x18,
-       0x30, 0x60, 0x18, 0xf5, 0x66, 0x33, 0x05, 0xb0,
-       0x8f, 0xda, 0xcd, 0x01, 0x53, 0xd6, 0x37, 0x33,
-       0xd7, 0x3b, 0xbe, 0x55, 0x79, 0xaa, 0xf8, 0x0c,
-       0x96, 0xcc, 0x07, 0xe8, 0xf9, 0x50, 0x5f, 0x57,
-       0x51, 0x53, 0xdf, 0xeb, 0x07, 0x3e, 0x0a, 0x3a,
-       0x2a, 0x50, 0x0b, 0x33, 0xd3, 0x8f, 0x33, 0x3d,
-       0x0c, 0x54, 0x30, 0x1a, 0x7a, 0x18, 0xfd, 0xbd,
-       0x2e, 0xd0, 0x87, 0xbb, 0xc2, 0x70, 0x2f, 0x59,
-       0x7e, 0x17, 0xea, 0xfd, 0x69, 0xa4, 0x8e, 0x43,
-       0x6c, 0x9c, 0x4a, 0xdd, 0xca, 0xa8, 0x5b, 0xc9,
-       0x1b, 0x21, 0x36, 0x5e, 0xa5, 0x3e, 0xc3, 0xa8,
-       0xcf, 0x20, 0xd5, 0x86, 0x98, 0x4d, 0xa5, 0x3e,
-       0x3b, 0x99, 0x34, 0x94, 0x0d, 0xc6, 0xca, 0x53,
-       0x13, 0x98, 0x9e, 0xc3, 0x2e, 0x9e, 0xfb, 0x94,
-       0x16, 0x5c, 0x23, 0x0b, 0xd3, 0x5b, 0x70, 0xdd,
-       0x5a, 0x30, 0xbd, 0x45, 0x77, 0x56, 0x77, 0x16,
-       0x29, 0xa7, 0xe1, 0x34, 0x86, 0xad, 0x3a, 0x2b,
-       0x5e, 0xf5, 0x3a, 0x3d, 0xc6, 0xae, 0x81, 0x35,
-       0x78, 0x7d, 0x16, 0x9e, 0x45, 0xca, 0x49, 0xdd,
-       0x49, 0xe4, 0x79, 0x12, 0x9e, 0xc4, 0xeb, 0x26,
-       0xd8, 0x84, 0x94, 0x41, 0xdd, 0xe0, 0x94, 0x16,
-       0x9d, 0x59, 0x67, 0xc6, 0xb0, 0x49, 0x67, 0xc2,
-       0x30, 0x36, 0x00, 0xf2, 0x3f, 0x8d, 0x25, 0x6f,
-       0x81, 0x67, 0xb0, 0x4c, 0x2d, 0xb0, 0x15, 0xb6,
-       0x56, 0x9e, 0xd2, 0xb3, 0xbc, 0x21, 0x32, 0x66,
-       0x10, 0x22, 0xf0, 0x93, 0xa3, 0x80, 0x30, 0x0a,
-       0x3f, 0xf9, 0x05, 0x41, 0x03, 0xfc, 0xe4, 0x8c,
-       0x6e, 0x0c, 0x8d, 0x36, 0x3f, 0xb9, 0x48, 0xb0,
-       0x1b, 0x7e, 0xf2, 0x1b, 0x1d, 0x8f, 0x7f, 0x17,
-       0xc8, 0x9a, 0x7d, 0x33, 0xa6, 0x77, 0xe1, 0x18,
-       0x54, 0x80, 0xa3, 0x36, 0x70, 0x29, 0x5a, 0xa8,
-       0x3f, 0x4c, 0x96, 0x97, 0xf6, 0x19, 0xb3, 0xe8,
-       0x4d, 0x8a, 0x89, 0xb0, 0x5b, 0x21, 0x50, 0xc9,
-       0xd7, 0xd1, 0x35, 0xee, 0x15, 0xfa, 0x54, 0xbb,
-       0x04, 0x1d, 0xe9, 0x7e, 0xd7, 0xbc, 0xb7, 0xa2,
-       0x57, 0xdc, 0x03, 0xbf, 0xed, 0x11, 0xcc, 0xc4,
-       0xe3, 0x4d, 0x0b, 0x9a, 0x25, 0x78, 0xd8, 0xa4,
-       0xf1, 0x05, 0xa6, 0xae, 0x48, 0x24, 0xce, 0xe0,
-       0x55, 0xce, 0x59, 0x79, 0x4a, 0x37, 0xaa, 0xaa,
-       0xb3, 0x7c, 0x50, 0x80, 0xa1, 0x35, 0xff, 0x74,
-       0x9a, 0x71, 0x9c, 0x14, 0x4d, 0xd3, 0xd9, 0xac,
-       0x85, 0x66, 0x33, 0x6f, 0x5e, 0x90, 0xc0, 0xbf,
-       0x84, 0xf7, 0x00, 0xea, 0x91, 0x15, 0xb8, 0x56,
-       0x9c, 0x8c, 0x9a, 0x47, 0x4f, 0x55, 0x1a, 0x00,
-       0xf7, 0x45, 0x9d, 0x2b, 0x78, 0x8b, 0x10, 0xa1,
-       0xd9, 0x87, 0x04, 0x89, 0xa5, 0xac, 0x8c, 0x0f,
-       0xc8, 0xad, 0x12, 0x4c, 0xef, 0x66, 0xe1, 0xc5,
-       0x4a, 0x1a, 0x4b, 0x55, 0x10, 0x64, 0x65, 0x1a,
-       0xf3, 0xa2, 0x04, 0xcb, 0xaf, 0x4a, 0xb0, 0xc2,
-       0xc4, 0x62, 0xef, 0xbf, 0x2e, 0xf6, 0x2d, 0x8c,
-       0x3d, 0x21, 0x41, 0x67, 0x9f, 0x04, 0x21, 0x2f,
-       0xf3, 0xc1, 0x2b, 0x25, 0x18, 0x1f, 0x62, 0xfe,
-       0x6d, 0x80, 0x4a, 0x73, 0x78, 0xaf, 0x04, 0xde,
-       0x4b, 0x6c, 0x54, 0xb8, 0x82, 0xb1, 0x98, 0x8f,
-       0xef, 0x24, 0xf3, 0x05, 0x0b, 0x98, 0xbc, 0x25,
-       0x8a, 0x89, 0xc6, 0xe6, 0x99, 0x0b, 0xa8, 0x07,
-       0xbf, 0xb1, 0x59, 0x82, 0xb2, 0xb1, 0x02, 0xf9,
-       0x0e, 0xf4, 0x21, 0x3d, 0x5d, 0xd0, 0xbf, 0xfc,
-       0x12, 0x6a, 0xfc, 0x11, 0x8c, 0xff, 0x6b, 0x75,
-       0x76, 0x37, 0x56, 0x9d, 0xdd, 0xa5, 0xb0, 0xd9,
-       0x9d, 0x95, 0xcf, 0xee, 0xf8, 0x4c, 0x4e, 0x82,
-       0x6b, 0xeb, 0x43, 0x90, 0x4a, 0x7c, 0x93, 0xf2,
-       0xf7, 0x63, 0x9a, 0x10, 0xb7, 0xbc, 0xe9, 0x5d,
-       0x8f, 0x02, 0x59, 0x6c, 0x44, 0x80, 0xad, 0x01,
-       0x3d, 0xcb, 0x5b, 0x62, 0x79, 0x4b, 0xca, 0x55,
-       0xb4, 0xf0, 0x7e, 0x56, 0xea, 0xa7, 0x59, 0x1f,
-       0x7e, 0x5a, 0x36, 0x56, 0x05, 0x05, 0xa0, 0xb9,
-       0x80, 0x8d, 0x38, 0xfe, 0x9a, 0x5a, 0x62, 0xe6,
-       0xd3, 0x8a, 0xbd, 0x86, 0xc5, 0xd6, 0xb8, 0xa9,
-       0xce, 0x33, 0xb7, 0xd8, 0x6c, 0xb6, 0x3e, 0xd0,
-       0xa1, 0x06, 0x07, 0xa8, 0x2d, 0x52, 0xa0, 0x87,
-       0xf1, 0x2a, 0xb6, 0xe1, 0xb9, 0x8b, 0x56, 0x26,
-       0x33, 0xb4, 0xcc, 0x68, 0xc3, 0xd9, 0xc8, 0x18,
-       0xba, 0x93, 0xf2, 0xd7, 0x34, 0x5f, 0x9d, 0xf9,
-       0x84, 0x04, 0x09, 0xe7, 0xb9, 0xde, 0x15, 0x1c,
-       0x3b, 0x60, 0x0f, 0xf9, 0x32, 0xeb, 0xeb, 0x8c,
-       0xb2, 0x40, 0x81, 0xe8, 0x0a, 0xd2, 0x88, 0x37,
-       0x95, 0x4a, 0xc1, 0x7b, 0x14, 0xef, 0x6d, 0xbc,
-       0x36, 0x6a, 0x7b, 0x61, 0x8a, 0xe0, 0x71, 0x1c,
-       0x93, 0xc6, 0x31, 0x1d, 0x57, 0x4b, 0x30, 0xf7,
-       0xd0, 0x4c, 0xb2, 0x49, 0xe7, 0x4a, 0xc3, 0x2c,
-       0x4c, 0xed, 0xcb, 0x5e, 0x6d, 0xf0, 0xdd, 0xae,
-       0x58, 0xf2, 0x0f, 0x10, 0x4d, 0x82, 0x6f, 0x1c,
-       0xf1, 0x97, 0xce, 0xfb, 0x79, 0xf4, 0x62, 0xfe,
-       0x29, 0xc2, 0xab, 0x3a, 0xe3, 0xeb, 0xac, 0x5c,
-       0x65, 0x32, 0xb7, 0x2c, 0x3b, 0x4f, 0x39, 0xf2,
-       0x98, 0x00, 0xaf, 0xff, 0x16, 0x4d, 0xfb, 0x54,
-       0xcf, 0xa9, 0x6c, 0xd4, 0x9a, 0x99, 0x67, 0x73,
-       0xa2, 0xef, 0x7e, 0x88, 0xfb, 0x46, 0x36, 0x0a,
-       0xa7, 0xe2, 0x1c, 0x7e, 0x07, 0x1b, 0x35, 0x53,
-       0xd9, 0xdc, 0x02, 0x2d, 0x60, 0x16, 0xa0, 0xa6,
-       0xb6, 0xa5, 0xd6, 0x4a, 0xb0, 0xec, 0x6d, 0x2a,
-       0xcf, 0xac, 0x66, 0x07, 0x1b, 0x9b, 0xba, 0x12,
-       0x9c, 0xcc, 0xb6, 0x37, 0x76, 0xc1, 0x88, 0x57,
-       0xff, 0x4d, 0x71, 0xf9, 0xd7, 0x63, 0x0b, 0x5c,
-       0xed, 0x4a, 0xe0, 0x3c, 0x33, 0x58, 0xdc, 0xb3,
-       0x18, 0x97, 0x79, 0x64, 0xaa, 0x55, 0x82, 0xd9,
-       0x7b, 0x48, 0xdf, 0xe5, 0x91, 0x40, 0x22, 0xd5,
-       0xb2, 0xf7, 0x31, 0xc7, 0x43, 0xc7, 0x23, 0x9c,
-       0x82, 0x72, 0x57, 0xcc, 0x7b, 0x27, 0x7a, 0xc2,
-       0xfb, 0x8f, 0x11, 0xa8, 0x7c, 0x95, 0xbc, 0xa8,
-       0xd7, 0xe6, 0x73, 0x2d, 0x33, 0xa7, 0x16, 0x83,
-       0x20, 0x41, 0x7b, 0x75, 0xe5, 0xff, 0x04, 0x43,
-       0x60, 0x44, 0xba, 0xc9, 0xab, 0xc6, 0x21, 0x7d,
-       0x06, 0xd2, 0x8b, 0x58, 0xfb, 0x3d, 0xd1, 0x83,
-       0xed, 0x81, 0x65, 0xee, 0x46, 0x58, 0x25, 0xdb,
-       0x6d, 0x7b, 0xe1, 0x11, 0x9c, 0x55, 0x92, 0x87,
-       0xae, 0xe5, 0xb6, 0xc8, 0xf5, 0x8f, 0xb1, 0x73,
-       0xe4, 0x7a, 0x8a, 0xd5, 0x72, 0x48, 0xa7, 0xfa,
-       0xcf, 0xd8, 0x3f, 0x08, 0xd5, 0xbf, 0xd8, 0x67,
-       0xcd, 0x05, 0x1f, 0xe8, 0x64, 0x1b, 0xc2, 0x1a,
-       0x9c, 0xab, 0x99, 0x11, 0xfa, 0xc1, 0xa0, 0xd8,
-       0x11, 0x7a, 0x90, 0x9e, 0xa6, 0xd2, 0x93, 0x39,
-       0x5d, 0x66, 0x56, 0xee, 0xbd, 0xe5, 0x66, 0xf9,
-       0xf0, 0x31, 0x44, 0xf8, 0xcf, 0xfd, 0xb3, 0x00,
-       0x9b, 0x13, 0xcf, 0x14, 0x95, 0x4a, 0x66, 0xf1,
-       0x22, 0xb5, 0x2d, 0x9b, 0x05, 0x7b, 0xd5, 0xd1,
-       0xca, 0xac, 0x8d, 0x56, 0xe8, 0x7b, 0x23, 0x01,
-       0xc8, 0x8f, 0xd0, 0xac, 0x7a, 0x12, 0x5d, 0xc3,
-       0xd8, 0xce, 0xdb, 0x12, 0x9d, 0xe4, 0x8f, 0x77,
-       0xe2, 0xe8, 0x79, 0x67, 0x94, 0x8d, 0xcf, 0x38,
-       0x22, 0x1a, 0xd0, 0x5b, 0x72, 0xa9, 0xb2, 0x87,
-       0xd5, 0x40, 0x8c, 0xc9, 0x52, 0x47, 0x46, 0x92,
-       0x75, 0x7d, 0x6a, 0x6d, 0x3c, 0x35, 0xe8, 0xa8,
-       0x24, 0x65, 0x5e, 0xb4, 0xda, 0xb7, 0xc9, 0x9e,
-       0xc8, 0x93, 0xa1, 0xbd, 0xb1, 0x55, 0x20, 0x1f,
-       0xbf, 0x31, 0xe5, 0x55, 0x30, 0xce, 0xef, 0x66,
-       0xf7, 0x03, 0x4f, 0x7d, 0x02, 0xea, 0x5c, 0xff,
-       0x64, 0x55, 0x2f, 0xd9, 0x1a, 0x9f, 0x23, 0xb3,
-       0x7c, 0x25, 0x61, 0xda, 0x27, 0x2f, 0xc5, 0x7c,
-       0x60, 0xe5, 0xf4, 0xae, 0x4d, 0x3a, 0x1d, 0x4c,
-       0xc1, 0x15, 0xdb, 0x1f, 0xf6, 0xc1, 0x93, 0xdc,
-       0x23, 0x4e, 0x71, 0xe1, 0x98, 0xd1, 0x65, 0xc5,
-       0xf5, 0x19, 0xc3, 0xad, 0xd3, 0xb1, 0x54, 0x60,
-       0xd7, 0x85, 0x19, 0x1c, 0xab, 0x5b, 0x37, 0xa5,
-       0x0b, 0x8a, 0xe1, 0x18, 0x8e, 0x16, 0x6c, 0x3d,
-       0xc7, 0xae, 0x83, 0x22, 0x40, 0x5f, 0xec, 0xde,
-       0x29, 0xc0, 0x66, 0x92, 0x31, 0xa5, 0x2b, 0xbb,
-       0x0c, 0x3e, 0xc4, 0xb1, 0x05, 0xfd, 0x2b, 0x34,
-       0x13, 0xff, 0xed, 0xdd, 0xba, 0x93, 0xd3, 0xbb,
-       0x52, 0xdc, 0x38, 0xa2, 0xa8, 0x69, 0xa3, 0x3d,
-       0x3a, 0x0b, 0x97, 0x80, 0xd7, 0xaf, 0xeb, 0x22,
-       0x78, 0x35, 0xeb, 0x0e, 0xe0, 0x35, 0x59, 0xf7,
-       0x3e, 0x5e, 0xc7, 0xe9, 0xf6, 0xe3, 0x75, 0xbc,
-       0xee, 0x20, 0x5e, 0xcb, 0x75, 0x67, 0xa6, 0x77,
-       0xe9, 0xad, 0xba, 0x43, 0x8c, 0xff, 0x08, 0x5e,
-       0x0d, 0x3a, 0x2c, 0xa7, 0x1e, 0x74, 0x67, 0x31,
-       0x9c, 0xa0, 0x3b, 0x8c, 0xd7, 0x3b, 0x74, 0x6f,
-       0x63, 0xc9, 0x27, 0x62, 0xc9, 0xaf, 0x2b, 0xb3,
-       0xe8, 0x1d, 0xaa, 0x69, 0x36, 0xaf, 0xa9, 0xf0,
-       0x1f, 0xab, 0xe9, 0x90, 0x17, 0x59, 0x3e, 0x5e,
-       0xf5, 0x52, 0x26, 0xe6, 0xe3, 0x42, 0xe8, 0x8f,
-       0x9e, 0x91, 0xac, 0x24, 0x19, 0x9e, 0x61, 0x96,
-       0x89, 0xf3, 0x83, 0xc8, 0x41, 0xae, 0x7b, 0xf4,
-       0x09, 0x38, 0x06, 0x9a, 0x01, 0xed, 0x3c, 0x40,
-       0xe1, 0x0b, 0xba, 0x72, 0x38, 0x63, 0xc7, 0x7e,
-       0xb2, 0x52, 0x81, 0x6b, 0x05, 0x08, 0xcb, 0xb8,
-       0x9d, 0xcf, 0xfc, 0x0e, 0x93, 0x7f, 0x5c, 0xa6,
-       0x79, 0xf0, 0x4c, 0xe6, 0x63, 0x5c, 0xdc, 0x73,
-       0x72, 0x7f, 0x3a, 0x3a, 0x6c, 0x03, 0x3f, 0xf7,
-       0x40, 0xb0, 0xcc, 0xc4, 0xec, 0xf3, 0x38, 0xae,
-       0xc5, 0x4c, 0x34, 0xd2, 0x06, 0xf5, 0x36, 0x5c,
-       0xfd, 0xf4, 0xe0, 0x4f, 0x19, 0x40, 0x0f, 0x7b,
-       0xd9, 0xfc, 0x2a, 0xa7, 0x57, 0x9e, 0x6a, 0x30,
-       0xb0, 0xb1, 0x35, 0xa2, 0x8d, 0x94, 0x34, 0x0e,
-       0x79, 0xd3, 0xb1, 0x57, 0xbf, 0xc7, 0x29, 0x81,
-       0x09, 0xb1, 0xf1, 0x95, 0x8d, 0x9a, 0xcb, 0xf6,
-       0xf3, 0x51, 0xb3, 0x80, 0xf9, 0xc5, 0x63, 0xc5,
-       0x30, 0x25, 0x90, 0xa2, 0x71, 0x60, 0xec, 0xf3,
-       0x64, 0xa1, 0xbe, 0x3c, 0x27, 0x8b, 0xed, 0x75,
-       0x39, 0x73, 0x61, 0x80, 0xcb, 0x39, 0xe3, 0x0d,
-       0x42, 0x4a, 0x31, 0xac, 0x43, 0xc9, 0xcf, 0x07,
-       0x12, 0x63, 0x32, 0x75, 0x2c, 0xf6, 0x56, 0x26,
-       0xb9, 0x59, 0x1b, 0x8f, 0x0d, 0xa3, 0xa8, 0x4c,
-       0x11, 0x08, 0xc0, 0x90, 0xe4, 0xa5, 0xa5, 0x18,
-       0xfb, 0x66, 0xf4, 0x6a, 0xe5, 0x29, 0xc0, 0x12,
-       0x73, 0x8f, 0x63, 0xb3, 0x71, 0x9f, 0x63, 0x7a,
-       0x0f, 0xa1, 0xb8, 0x9c, 0xb0, 0xfa, 0x36, 0x0b,
-       0xd3, 0xd5, 0x93, 0xe4, 0x61, 0x10, 0x3f, 0xcd,
-       0xa8, 0x67, 0xda, 0x2c, 0x4c, 0x1f, 0x1a, 0xb5,
-       0x41, 0xe6, 0x5c, 0x7f, 0xa3, 0xe2, 0xbf, 0x92,
-       0x79, 0xbc, 0x86, 0x37, 0x2a, 0x26, 0xbc, 0x36,
-       0xa9, 0x5c, 0x1b, 0x55, 0xea, 0x59, 0x46, 0xfd,
-       0x50, 0xe5, 0xd5, 0xa8, 0x32, 0xa3, 0x2a, 0x2a,
-       0xef, 0x53, 0x2a, 0xf5, 0x23, 0x46, 0xfd, 0x58,
-       0xe5, 0x65, 0x54, 0x6c, 0x15, 0x30, 0x65, 0x93,
-       0x4f, 0x9e, 0xb9, 0x52, 0xb5, 0x14, 0xd0, 0x77,
-       0xb3, 0xf6, 0xcd, 0x94, 0x70, 0x7a, 0x4b, 0x3c,
-       0x9e, 0x1a, 0x56, 0xe3, 0xd2, 0x9d, 0xcb, 0x40,
-       0xdf, 0x86, 0xb3, 0x16, 0xc5, 0x5a, 0x83, 0x21,
-       0xff, 0x32, 0x5a, 0x7d, 0x2c, 0xeb, 0x47, 0xde,
-       0x07, 0xe4, 0x14, 0x96, 0x76, 0xa3, 0x62, 0x21,
-       0xef, 0x7d, 0x64, 0x89, 0x9a, 0x5f, 0x09, 0xcb,
-       0xaf, 0x54, 0xc6, 0x95, 0x73, 0x6b, 0xda, 0xcd,
-       0x24, 0xc9, 0xfb, 0x87, 0x24, 0x99, 0xba, 0x51,
-       0xda, 0x76, 0xe4, 0x9f, 0x2b, 0x17, 0x10, 0x2f,
-       0x62, 0x67, 0x98, 0xd4, 0x27, 0x15, 0xa3, 0xa7,
-       0x46, 0x1c, 0xe7, 0xab, 0x91, 0xd3, 0x0a, 0xf7,
-       0x42, 0xb5, 0x6f, 0x19, 0xf9, 0x60, 0x9e, 0x46,
-       0x79, 0x86, 0xd2, 0xd7, 0xd4, 0x50, 0x3b, 0x31,
-       0x0f, 0x3f, 0x43, 0x4d, 0xb9, 0x43, 0x4d, 0x69,
-       0xc2, 0x14, 0x73, 0xc5, 0x0c, 0x6b, 0x0d, 0xcc,
-       0x5d, 0x3e, 0xae, 0x70, 0x6f, 0x34, 0x1a, 0x9f,
-       0x7f, 0x0d, 0x93, 0x21, 0xcf, 0x20, 0x59, 0x7e,
-       0x92, 0x91, 0x81, 0x32, 0x2a, 0xd1, 0x1b, 0xbc,
-       0xa6, 0x4a, 0xa9, 0x57, 0xa5, 0xd8, 0xf2, 0xee,
-       0x06, 0xbd, 0x07, 0xb9, 0x7c, 0x6e, 0xc5, 0x8f,
-       0x9e, 0xe3, 0x69, 0x46, 0xff, 0x1b, 0xa5, 0x1c,
-       0x7d, 0x60, 0xd8, 0x53, 0x13, 0x1c, 0xc5, 0xfa,
-       0xd3, 0x49, 0xfd, 0x2a, 0x18, 0x45, 0x90, 0xdd,
-       0xb3, 0x3a, 0x19, 0xc1, 0xb1, 0x83, 0x59, 0xc4,
-       0xfb, 0xef, 0x46, 0x7c, 0xb6, 0x05, 0x6f, 0x46,
-       0x4f, 0x4a, 0xd0, 0xf8, 0x92, 0xbb, 0x0f, 0xe6,
-       0x5a, 0x71, 0xd6, 0x2b, 0x1b, 0x6b, 0x6a, 0x44,
-       0x9a, 0xe5, 0xe9, 0xc4, 0x72, 0x56, 0xa3, 0xe2,
-       0x90, 0x6e, 0xa8, 0xb6, 0x21, 0x1b, 0x7a, 0x41,
-       0x76, 0x4f, 0x60, 0x66, 0xa3, 0x6f, 0x07, 0x58,
-       0x17, 0xe0, 0x08, 0x1b, 0x1e, 0x8f, 0x65, 0xdd,
-       0x2d, 0x38, 0xc0, 0xaa, 0x58, 0xd2, 0x5d, 0x55,
-       0x4f, 0x29, 0xd8, 0xa3, 0x3f, 0x0b, 0xe0, 0x9c,
-       0x3a, 0x2a, 0x1a, 0x79, 0x4d, 0x96, 0x36, 0xb2,
-       0x71, 0x0c, 0xe0, 0x10, 0x2f, 0xff, 0xd2, 0xed,
-       0xaa, 0x44, 0x3b, 0x95, 0xff, 0x1e, 0x7a, 0x26,
-       0x54, 0x0a, 0xfa, 0x9d, 0x0c, 0xb2, 0x7a, 0x3c,
-       0x73, 0x7d, 0x3d, 0xfc, 0x5f, 0xb2, 0x1e, 0x0d,
-       0x67, 0x6f, 0x52, 0x8f, 0xca, 0x38, 0xdd, 0x7e,
-       0x51, 0x6d, 0x6c, 0x5a, 0x6d, 0x1a, 0xdf, 0xc6,
-       0xda, 0xd8, 0x86, 0x6a, 0x33, 0xb8, 0x9d, 0xd7,
-       0x86, 0xb7, 0x6d, 0xcb, 0xd3, 0x58, 0x9b, 0x05,
-       0xf2, 0x0a, 0xaa, 0x4b, 0x39, 0x9f, 0x41, 0x15,
-       0x23, 0xf5, 0xed, 0xf4, 0x62, 0x7a, 0x5a, 0x35,
-       0xfc, 0x29, 0xd7, 0xd1, 0x75, 0xfc, 0xf9, 0x16,
-       0xca, 0x78, 0x90, 0x59, 0xfc, 0x03, 0x93, 0x98,
-       0x45, 0xe3, 0xaf, 0x8b, 0x8f, 0xbc, 0x62, 0x0e,
-       0xa6, 0xdd, 0xc4, 0xa8, 0x5d, 0x14, 0x43, 0x1e,
-       0x61, 0xe6, 0x8c, 0xca, 0x73, 0x38, 0xda, 0x1b,
-       0x59, 0x49, 0x37, 0xcb, 0xfa, 0x7d, 0xee, 0xf4,
-       0xb5, 0x28, 0x61, 0x1c, 0x72, 0x8e, 0xc5, 0xbc,
-       0x17, 0xc9, 0x4e, 0xd6, 0x43, 0x78, 0xaf, 0xc8,
-       0x40, 0xaa, 0x3f, 0x96, 0xca, 0x04, 0xc6, 0x72,
-       0x35, 0xd5, 0x1b, 0x9e, 0x74, 0xf4, 0x1f, 0x7f,
-       0xfc, 0x48, 0x82, 0xe6, 0xb3, 0xb1, 0x1e, 0x74,
-       0x02, 0xd3, 0x57, 0xcb, 0xd5, 0xbc, 0x1d, 0x5a,
-       0xc6, 0xf2, 0xd9, 0x04, 0x79, 0xa7, 0x32, 0x0f,
-       0x95, 0xf7, 0x17, 0xfb, 0xd3, 0x8b, 0x69, 0xe8,
-       0x66, 0x94, 0x52, 0x56, 0x0f, 0x8f, 0x9f, 0x62,
-       0x52, 0x6b, 0x3c, 0xe9, 0xfb, 0xe6, 0x1d, 0xa6,
-       0xf9, 0xfa, 0x1f, 0x37, 0x07, 0xb9, 0xa7, 0xf1,
-       0xb0, 0xba, 0xe1, 0x4c, 0xab, 0xf9, 0x31, 0x94,
-       0x3a, 0x4f, 0x2e, 0x22, 0xa9, 0xd4, 0x62, 0x7c,
-       0xe5, 0x51, 0xfe, 0x85, 0x2b, 0x0f, 0x79, 0x47,
-       0x6c, 0x3d, 0xa1, 0xc3, 0xd4, 0xf3, 0xe5, 0x34,
-       0xad, 0x4e, 0x15, 0xd9, 0x34, 0x23, 0x9d, 0xf3,
-       0x1c, 0xcd, 0x48, 0xe7, 0x1c, 0xc2, 0x38, 0x37,
-       0x5a, 0x4e, 0x38, 0x56, 0xe3, 0x27, 0x95, 0x3c,
-       0xcc, 0x51, 0x9c, 0x09, 0xbc, 0xec, 0x4e, 0xb4,
-       0x20, 0xb2, 0x84, 0x5f, 0x44, 0x02, 0x73, 0x53,
-       0x06, 0x41, 0xa0, 0xf5, 0xa2, 0xa7, 0x86, 0xa8,
-       0x12, 0x34, 0xcd, 0x70, 0x4e, 0xc0, 0xbe, 0xf8,
-       0x91, 0xe8, 0xf2, 0xd5, 0x50, 0x1b, 0x35, 0x67,
-       0xf1, 0x34, 0x47, 0x7f, 0x51, 0x53, 0x41, 0x96,
-       0xc7, 0x67, 0x51, 0x65, 0xe7, 0x40, 0x17, 0x9c,
-       0xbb, 0xa9, 0x26, 0xe5, 0x04, 0xad, 0x47, 0x48,
-       0xc6, 0x4c, 0xe0, 0xe9, 0x1b, 0xaf, 0x39, 0x27,
-       0x50, 0x1f, 0x56, 0x9e, 0xc7, 0x52, 0x94, 0x63,
-       0x29, 0x0e, 0x73, 0xbd, 0x29, 0xbc, 0xff, 0x6f,
-       0x94, 0x97, 0xaa, 0x25, 0x52, 0xe5, 0x0e, 0xc9,
-       0x2c, 0x39, 0x07, 0xd5, 0x65, 0xe7, 0xa2, 0xd1,
-       0x60, 0xd5, 0xa6, 0x9a, 0x65, 0x79, 0x63, 0xd2,
-       0x49, 0x72, 0xea, 0x5e, 0x10, 0xc4, 0x4c, 0xad,
-       0x04, 0x37, 0xe6, 0x2f, 0xea, 0x6f, 0x52, 0x82,
-       0x2e, 0x56, 0x83, 0x0c, 0xb1, 0x0a, 0xaf, 0xad,
-       0x9e, 0x9a, 0x8c, 0x58, 0x3e, 0x21, 0x28, 0xd0,
-       0x51, 0x8b, 0x95, 0x5d, 0x72, 0x40, 0xc9, 0x79,
-       0xa8, 0x0e, 0x8c, 0xc9, 0x60, 0x33, 0x24, 0xa7,
-       0x0e, 0x53, 0x95, 0xfb, 0xdd, 0xbc, 0x37, 0xc9,
-       0x7d, 0x48, 0x1f, 0xa4, 0x16, 0xa5, 0x39, 0x2e,
-       0x8b, 0x43, 0x9f, 0x27, 0x1f, 0xc3, 0xfa, 0x3c,
-       0x24, 0x67, 0x51, 0x6d, 0xa6, 0xb2, 0x35, 0xd4,
-       0xad, 0x77, 0x48, 0x20, 0x72, 0xef, 0xf1, 0x1d,
-       0x85, 0xdd, 0x7d, 0x9a, 0xf9, 0x1d, 0xa2, 0xa7,
-       0x6e, 0x47, 0xfa, 0x46, 0xe1, 0x21, 0xe4, 0xf7,
-       0x60, 0xfd, 0x9f, 0x89, 0xb5, 0xc2, 0x46, 0x19,
-       0xf5, 0x29, 0x9f, 0x18, 0xaa, 0xb7, 0xdf, 0xad,
-       0xd5, 0x06, 0x6b, 0xcd, 0x6a, 0xc3, 0x6b, 0x3d,
-       0xa6, 0x78, 0xa8, 0x36, 0x0d, 0x2f, 0x53, 0x6d,
-       0xe4, 0x05, 0xa2, 0x1f, 0xaf, 0xcf, 0xc6, 0x6a,
-       0xc3, 0x6c, 0xcd, 0xef, 0x1e, 0x5e, 0xa3, 0x68,
-       0x0f, 0xae, 0x3d, 0xc7, 0xdc, 0x39, 0x51, 0xab,
-       0x53, 0x43, 0xb0, 0xc6, 0x4d, 0x3d, 0x58, 0x3e,
-       0x8f, 0xd4, 0xe2, 0xf8, 0x1a, 0x35, 0xd4, 0xa1,
-       0x34, 0xbd, 0x36, 0xca, 0xd1, 0x1a, 0xed, 0x9b,
-       0x87, 0x15, 0x23, 0x96, 0xd4, 0x85, 0x2b, 0x08,
-       0x75, 0xcc, 0x83, 0xfd, 0xda, 0x98, 0x02, 0x7b,
-       0x90, 0x3b, 0x9d, 0x95, 0x3b, 0x4f, 0xf3, 0xc5,
-       0x0c, 0x2b, 0x54, 0x47, 0x0a, 0x8e, 0x4d, 0x4b,
-       0xcd, 0x05, 0x60, 0xba, 0x41, 0x69, 0x3e, 0x9b,
-       0x82, 0x36, 0x1b, 0x37, 0x16, 0x6d, 0x52, 0x8a,
-       0xc8, 0x73, 0xb7, 0x2e, 0xe6, 0xf5, 0xcf, 0xa8,
-       0x38, 0xfa, 0x8b, 0x21, 0x3b, 0xfc, 0x97, 0x48,
-       0x19, 0xb6, 0x47, 0xc5, 0xf9, 0x68, 0xf4, 0x96,
-       0x8c, 0x57, 0xdf, 0x94, 0x07, 0x52, 0xd6, 0xf9,
-       0x55, 0x7b, 0xac, 0x7f, 0x59, 0x74, 0x54, 0x7e,
-       0x07, 0x0c, 0x58, 0xe6, 0x3c, 0x7f, 0x0d, 0x4a,
-       0xa8, 0x5e, 0x6e, 0x1f, 0x36, 0xf2, 0xa0, 0xdd,
-       0x8b, 0x5e, 0xee, 0x67, 0x7c, 0x36, 0xf9, 0x09,
-       0x0f, 0xab, 0x8b, 0xf0, 0x10, 0x5a, 0x72, 0x3a,
-       0x5b, 0xeb, 0x5c, 0xe5, 0x65, 0x20, 0x69, 0x35,
-       0x2e, 0xe6, 0xb7, 0x66, 0x50, 0x9e, 0xef, 0x46,
-       0xa8, 0xff, 0x97, 0xbe, 0x1f, 0x9c, 0x9b, 0x72,
-       0x9c, 0x74, 0xee, 0x31, 0xba, 0x19, 0x6e, 0xb3,
-       0x2b, 0x66, 0xac, 0xbf, 0xa0, 0x5c, 0x11, 0x93,
-       0xc9, 0x13, 0x73, 0x4f, 0xe7, 0xef, 0xae, 0x3e,
-       0x50, 0xd3, 0x4d, 0x77, 0x71, 0x26, 0x36, 0x07,
-       0xc1, 0x97, 0xa2, 0xe4, 0x64, 0xfa, 0xd2, 0xbd,
-       0x69, 0xb7, 0x2b, 0x36, 0xdb, 0x6d, 0x12, 0x2c,
-       0xb4, 0xef, 0x06, 0xe5, 0x12, 0xd6, 0x20, 0x55,
-       0x3c, 0x9b, 0x9e, 0x05, 0xe6, 0x9d, 0x7b, 0x61,
-       0x5b, 0xcd, 0x11, 0xc5, 0x34, 0xe9, 0x30, 0xa5,
-       0xcd, 0x48, 0x12, 0xcf, 0x72, 0xeb, 0xf0, 0xad,
-       0x55, 0x44, 0x9f, 0x51, 0xce, 0x29, 0xa3, 0x12,
-       0x9d, 0x70, 0xa6, 0x70, 0x4f, 0x1c, 0x5f, 0x9a,
-       0x40, 0x95, 0x8d, 0x59, 0xa4, 0xdf, 0xaf, 0xf7,
-       0xc3, 0xa8, 0xfc, 0xa3, 0xe4, 0xb3, 0x99, 0x0f,
-       0xfc, 0xb6, 0xe0, 0x99, 0x3d, 0xc0, 0x57, 0x6b,
-       0x65, 0x15, 0xec, 0xea, 0x9b, 0xf4, 0x0e, 0x96,
-       0xa6, 0x91, 0xad, 0x0d, 0x66, 0x33, 0x4a, 0xe5,
-       0x54, 0x1d, 0x6f, 0xd1, 0xb4, 0x7c, 0x09, 0x1e,
-       0x4c, 0xe6, 0xf1, 0x2c, 0x66, 0x76, 0xce, 0x6a,
-       0x68, 0x96, 0xe0, 0x77, 0x83, 0x34, 0x7f, 0x97,
-       0x20, 0xc7, 0xc7, 0xee, 0xbb, 0x57, 0x2a, 0xa9,
-       0xee, 0x01, 0x28, 0x94, 0xe0, 0x81, 0x33, 0x6e,
-       0x76, 0xf7, 0x9d, 0xaf, 0xfb, 0x6f, 0x6e, 0xd1,
-       0x0f, 0xbc, 0xce, 0xf0, 0x6f, 0x93, 0x57, 0xaf,
-       0xea, 0xcc, 0xca, 0xca, 0x12, 0x1a, 0xda, 0x97,
-       0x2f, 0x97, 0xda, 0x1a, 0x85, 0x86, 0xa0, 0xd4,
-       0xd1, 0xdc, 0xd4, 0x28, 0x20, 0xcd, 0xc2, 0x9f,
-       0x37, 0xf9, 0xb5, 0x07, 0x4f, 0xdb, 0x16, 0x05,
-       0xb5, 0xa0, 0x37, 0x46, 0x5b, 0x52, 0x0a, 0xdb,
-       0x1e, 0xb0, 0xe1, 0xaf, 0x7a, 0xce, 0x4d, 0x68,
-       0xa5, 0x31, 0xda, 0x7d, 0xbd, 0xb0, 0x4d, 0x4e,
-       0xc7, 0xdf, 0x7e, 0x4f, 0x8c, 0x26, 0xe5, 0x68,
-       0xc1, 0x92, 0x18, 0x4d, 0x5c, 0xaa, 0x05, 0x6b,
-       0x63, 0xb4, 0x87, 0x36, 0xc6, 0x9e, 0x85, 0xc7,
-       0x68, 0x0f, 0x0c, 0xc0, 0xb6, 0x07, 0xcb, 0xf1,
-       0xd7, 0x5d, 0x1d, 0xa3, 0xed, 0x39, 0xae, 0x05,
-       0x67, 0xc6, 0x68, 0x75, 0x9b, 0xb5, 0x60, 0x65,
-       0x8c, 0x56, 0xab, 0xd7, 0x82, 0x75, 0x31, 0x5a,
-       0xcd, 0x11, 0x2d, 0x38, 0x6b, 0x88, 0xd6, 0xa7,
-       0x05, 0xcb, 0x63, 0xb4, 0xea, 0x58, 0x92, 0xb9,
-       0x31, 0x5a, 0x71, 0x8c, 0xe6, 0x8e, 0xaf, 0xaf,
-       0xfa, 0x57, 0x13, 0xa3, 0x4d, 0xb7, 0x6a, 0xc1,
-       0x79, 0x43, 0x7c, 0x31, 0x15, 0x95, 0xc5, 0x68,
-       0x05, 0x57, 0x61, 0xdb, 0xd7, 0x5e, 0xc4, 0xdf,
-       0x89, 0xf2, 0x0a, 0x8d, 0x36, 0xaf, 0x59, 0x8b,
-       0xf6, 0x6b, 0x02, 0xb7, 0xcd, 0x7f, 0x41, 0xa3,
-       0x2d, 0x1c, 0xa2, 0xbd, 0x14, 0xd3, 0x69, 0x69,
-       0xac, 0xbe, 0x21, 0x8d, 0x56, 0xaa, 0x55, 0x64,
-       0x9b, 0xf2, 0x58, 0xac, 0xcc, 0x43, 0xb4, 0xac,
-       0x98, 0xee, 0x63, 0xf2, 0x2a, 0x62, 0x75, 0xab,
-       0x8d, 0xf1, 0xcd, 0x5e, 0x1c, 0xab, 0x9b, 0x3b,
-       0x56, 0xb7, 0x0d, 0x31, 0x3d, 0xc7, 0x68, 0x25,
-       0x72, 0x8c, 0x16, 0x93, 0x57, 0xfb, 0x62, 0x2c,
-       0xad, 0xd6, 0x70, 0xdb, 0x7e, 0xe6, 0xd4, 0x68,
-       0x1e, 0x4f, 0xac, 0x1e, 0x5d, 0x31, 0xdd, 0xc7,
-       0xd2, 0x3a, 0x63, 0xfa, 0x9b, 0xb3, 0x50, 0xa3,
-       0x65, 0xc7, 0x4c, 0xd1, 0x1f, 0xab, 0x6f, 0xe3,
-       0x13, 0x43, 0x7c, 0x2a, 0x71, 0xdb, 0xd4, 0x13,
-       0x43, 0x75, 0xd3, 0x68, 0x15, 0x31, 0xd3, 0x29,
-       0xaf, 0x50, 0x2b, 0xb7, 0xcd, 0xbf, 0x26, 0xa6,
-       0xab, 0x0a, 0xff, 0x0d, 0x65, 0xae, 0x76, 0x57,
-       0x6a, 0x6d, 0xfe, 0x9e, 0x46, 0xcb, 0xcf, 0x9d,
-       0xad, 0xd1, 0x06, 0x62, 0xf5, 0x2d, 0xd3, 0xf2,
-       0x28, 0xde, 0xaf, 0xd1, 0x2a, 0x4a, 0xd5, 0x16,
-       0xde, 0x76, 0x4f, 0xac, 0xcc, 0xa5, 0x65, 0x9a,
-       0xbc, 0x42, 0x47, 0x2c, 0x8f, 0x58, 0x99, 0xe3,
-       0xda, 0x2d, 0x4f, 0x2b, 0x5f, 0xfe, 0xc5, 0x58,
-       0x99, 0xf3, 0x34, 0xbe, 0x82, 0x07, 0x35, 0xda,
-       0x82, 0x32, 0xad, 0xcc, 0x77, 0x9d, 0x1d, 0x6a,
-       0x23, 0xb5, 0x77, 0x6d, 0x73, 0xb9, 0x62, 0xb6,
-       0x31, 0x57, 0xad, 0xfa, 0x36, 0xc7, 0xba, 0x58,
-       0xdf, 0xaa, 0xad, 0x29, 0x51, 0xcb, 0x1c, 0xb3,
-       0xfb, 0xda, 0x45, 0xd5, 0x65, 0xaa, 0xdd, 0x97,
-       0xc7, 0xa5, 0x5d, 0xc4, 0x69, 0xf7, 0xf6, 0x0d,
-       0xe9, 0xc5, 0x5f, 0xab, 0xd6, 0x23, 0xc6, 0x37,
-       0xbb, 0xa2, 0xb2, 0x52, 0xed, 0x47, 0x31, 0x5d,
-       0x95, 0xfa, 0x2b, 0x16, 0x94, 0x71, 0xda, 0x90,
-       0x9e, 0xcb, 0x3c, 0xf3, 0x59, 0x9f, 0xdb, 0x56,
-       0x79, 0x29, 0xd6, 0x6e, 0x73, 0x6b, 0xe7, 0xb2,
-       0x9a, 0x6c, 0xf3, 0x7e, 0x14, 0xd3, 0x5f, 0x55,
-       0x2d, 0xd7, 0xd6, 0x36, 0x6f, 0x4c, 0x07, 0x65,
-       0x75, 0x25, 0x65, 0xd5, 0x5c, 0x2f, 0xb1, 0xfe,
-       0x31, 0x67, 0xb6, 0xda, 0x72, 0xdb, 0xa6, 0xb7,
-       0xc6, 0xca, 0x5c, 0x59, 0xe6, 0xe6, 0xb4, 0xdc,
-       0x98, 0xcf, 0xf1, 0x97, 0x79, 0xe6, 0xce, 0xad,
-       0x65, 0x65, 0x89, 0xe5, 0x51, 0x3e, 0xd7, 0x3f,
-       0xc7, 0xcd, 0x68, 0x0b, 0x63, 0x7b, 0xc4, 0xe6,
-       0xce, 0xaf, 0xad, 0x9e, 0xcf, 0x68, 0xd3, 0x8e,
-       0xc5, 0x74, 0x5a, 0x56, 0x3b, 0xc7, 0x4d, 0x19,
-       0x6f, 0xcb, 0x9b, 0x11, 0xf3, 0x89, 0x73, 0xfd,
-       0x55, 0x65, 0x8c, 0xaf, 0x22, 0x2d, 0x96, 0xaf,
-       0x77, 0x76, 0x69, 0x0d, 0x99, 0xc7, 0xb6, 0x05,
-       0xbb, 0x86, 0xe7, 0x31, 0x8f, 0xf2, 0x38, 0x3e,
-       0x64, 0x6b, 0x35, 0xb3, 0x91, 0x77, 0x18, 0xdf,
-       0x1c, 0xf7, 0xec, 0x32, 0x56, 0x93, 0xb8, 0x7a,
-       0x78, 0xcb, 0xea, 0x2a, 0xe7, 0x96, 0x10, 0xdf,
-       0x5d, 0xd7, 0x62, 0x7d, 0x3f, 0xe6, 0x23, 0xde,
-       0x8e, 0xb5, 0xe5, 0x42, 0xcd, 0xd9, 0x6d, 0x7b,
-       0xcb, 0x77, 0xa3, 0x8f, 0x38, 0x12, 0xf3, 0x7f,
-       0x0b, 0x63, 0x7d, 0xe6, 0xc8, 0x95, 0x18, 0x6d,
-       0x5e, 0x8c, 0xf6, 0x76, 0x8c, 0x56, 0xad, 0xd9,
-       0xd5, 0xcf, 0x37, 0xc5, 0xd1, 0x16, 0xaa, 0xb4,
-       0xfd, 0x43, 0xb4, 0x85, 0x1a, 0xdf, 0xa5, 0x21,
-       0x9a, 0x66, 0xa7, 0x6f, 0xa7, 0x0f, 0xd1, 0x6a,
-       0xe6, 0x94, 0x70, 0x9a, 0xff, 0x0b, 0xf7, 0x3a,
-       0x0c, 0x80, 0x05, 0x47, 0x64, 0x9b, 0x08, 0x9f,
-       0x9a, 0xd4, 0xfd, 0x0e, 0x2b, 0x68, 0xc3, 0x83,
-       0x05, 0x6c, 0x76, 0x36, 0xae, 0x5f, 0xb5, 0x39,
-       0xa2, 0x51, 0x09, 0xe6, 0x36, 0xb2, 0xd5, 0x69,
-       0x96, 0xcd, 0x86, 0xe1, 0x3a, 0x5a, 0x6f, 0x2a,
-       0x29, 0x6c, 0xc6, 0x6a, 0xa7, 0x71, 0xae, 0x62,
-       0x0c, 0xca, 0x19, 0x27, 0xda, 0xaa, 0x3f, 0x55,
-       0xc3, 0x13, 0x44, 0x23, 0x5e, 0xef, 0x92, 0x60,
-       0xc1, 0x6e, 0x11, 0xae, 0xbe, 0xe4, 0x6d, 0x5a,
-       0x29, 0x2c, 0x6f, 0x6f, 0x6c, 0x12, 0xda, 0x65,
-       0x59, 0xb0, 0xc0, 0x10, 0xda, 0x86, 0xd8, 0x02,
-       0xa9, 0xb5, 0xa5, 0x51, 0x90, 0x82, 0x4a, 0xe7,
-       0xf2, 0xa6, 0xb6, 0x50, 0xc7, 0x34, 0xa4, 0x66,
-       0xab, 0x8c, 0xab, 0x21, 0x9b, 0xee, 0x98, 0x95,
-       0x4a, 0x50, 0x53, 0xb9, 0x0c, 0xaa, 0x9e, 0x68,
-       0x4b, 0xcb, 0x82, 0xc3, 0x5d, 0xd1, 0x6b, 0x88,
-       0x17, 0x23, 0xde, 0xd5, 0x66, 0xca, 0x86, 0x23,
-       0x88, 0xef, 0xfd, 0x66, 0x03, 0x54, 0xb5, 0x09,
-       0x65, 0xe9, 0xe5, 0x52, 0x9d, 0xef, 0x5b, 0x8a,
-       0x05, 0xf3, 0x16, 0x30, 0xef, 0x69, 0x22, 0x8d,
-       0xd8, 0xb9, 0x18, 0x72, 0xf2, 0xfb, 0x28, 0xdf,
-       0xdd, 0x8b, 0x23, 0x7d, 0x06, 0x96, 0x68, 0x6c,
-       0x49, 0x7b, 0x67, 0x6b, 0x63, 0xdb, 0x5d, 0x21,
-       0x41, 0x6e, 0xa1, 0x31, 0xb9, 0x3d, 0x10, 0x68,
-       0x0a, 0x4e, 0x69, 0x6d, 0xe9, 0x08, 0x59, 0xa0,
-       0x64, 0x08, 0x11, 0xe4, 0xf6, 0x4e, 0x8c, 0x96,
-       0x42, 0x42, 0x06, 0x78, 0x3f, 0x76, 0x39, 0x25,
-       0xf8, 0xf5, 0xa6, 0xfc, 0xc1, 0x47, 0xc3, 0x70,
-       0xaa, 0xff, 0x69, 0xba, 0xab, 0x27, 0x01, 0x9c,
-       0x58, 0x13, 0x0d, 0x5e, 0x7b, 0xe5, 0xcd, 0x56,
-       0xdf, 0xce, 0x8d, 0x8a, 0xb1, 0xb6, 0x5b, 0xbc,
-       0x9c, 0xe1, 0xad, 0xed, 0xce, 0xf4, 0x2d, 0xda,
-       0x20, 0x89, 0x4a, 0x5f, 0xd9, 0xf9, 0x6b, 0xf0,
-       0x43, 0xba, 0xbb, 0x07, 0xad, 0xc6, 0xbf, 0x3d,
-       0x8c, 0xab, 0x8d, 0x4a, 0xf9, 0x02, 0xce, 0x7b,
-       0x84, 0x1f, 0xbe, 0xd5, 0x6e, 0xcc, 0x98, 0x8d,
-       0x78, 0xb1, 0xd2, 0x8f, 0x9c, 0x85, 0xf2, 0x40,
-       0xdd, 0x86, 0x35, 0x20, 0x58, 0xe8, 0x39, 0xf1,
-       0x77, 0xf7, 0x4e, 0x85, 0x00, 0x49, 0xbe, 0x20,
-       0xe0, 0x4c, 0xf6, 0xd7, 0x2b, 0xf3, 0x07, 0x81,
-       0xe5, 0x97, 0x3f, 0xf8, 0x48, 0x14, 0xe1, 0x33,
-       0x34, 0x27, 0xa9, 0x3c, 0x65, 0xd5, 0xd3, 0x6c,
-       0x6d, 0x1d, 0x38, 0x53, 0xcc, 0x28, 0x9d, 0xcd,
-       0xc1, 0xfa, 0xeb, 0xad, 0x62, 0xb2, 0xcf, 0xa5,
-       0x98, 0x7a, 0xba, 0x74, 0xd7, 0x1a, 0x68, 0xaf,
-       0x45, 0x41, 0xfe, 0x00, 0x14, 0x51, 0x9a, 0xec,
-       0x14, 0xa1, 0x18, 0x9e, 0x09, 0x43, 0x78, 0x35,
-       0x38, 0x32, 0xc2, 0xfc, 0x69, 0x4f, 0x9f, 0x8e,
-       0xdd, 0x03, 0x44, 0xd8, 0x70, 0x05, 0x57, 0xbb,
-       0xa7, 0xfa, 0xc7, 0x67, 0xac, 0x8f, 0xac, 0x06,
-       0x73, 0xe5, 0x29, 0x70, 0xd3, 0xbe, 0x3a, 0xef,
-       0xc7, 0x91, 0x70, 0x5e, 0x31, 0xd8, 0xa4, 0xf1,
-       0x8a, 0x0d, 0xa1, 0x51, 0x4a, 0x53, 0xcc, 0xa8,
-       0xcd, 0x02, 0x09, 0x6a, 0xcf, 0xe4, 0xef, 0x83,
-       0x6d, 0x93, 0x07, 0x71, 0x5d, 0x65, 0xa8, 0xea,
-       0xc4, 0x30, 0xe6, 0xf0, 0x79, 0x32, 0x23, 0x28,
-       0x6b, 0xb8, 0xae, 0x25, 0x41, 0x0e, 0x36, 0x35,
-       0x09, 0x2d, 0x6d, 0xa1, 0xa6, 0x60, 0xb0, 0x33,
-       0x10, 0x12, 0x26, 0x5a, 0x68, 0xd7, 0xcc, 0xd5,
-       0x62, 0x9c, 0x61, 0x77, 0x45, 0x67, 0xb1, 0xa7,
-       0x63, 0xc2, 0xdd, 0x10, 0x96, 0x4c, 0x7c, 0xee,
-       0xc4, 0x29, 0xec, 0xa9, 0xd9, 0xc9, 0xc2, 0xbb,
-       0x75, 0x26, 0xb3, 0x01, 0x92, 0x14, 0x13, 0xe1,
-       0x7f, 0x77, 0xf2, 0xe3, 0xfb, 0x0f, 0x76, 0x41,
-       0xe2, 0x6f, 0x66, 0x1f, 0x7d, 0x83, 0xe6, 0x9a,
-       0x77, 0x7b, 0x49, 0x17, 0x38, 0x24, 0x3e, 0x21,
-       0xb8, 0x1c, 0x5e, 0x09, 0x0a, 0xc4, 0xca, 0x67,
-       0xc0, 0x50, 0xd7, 0xcd, 0xa8, 0xad, 0x3d, 0x5d,
-       0x7a, 0x68, 0x0c, 0xf4, 0x74, 0x41, 0xb7, 0x6c,
-       0x12, 0x96, 0x41, 0x58, 0x3c, 0x89, 0xe1, 0x0d,
-       0x2c, 0xfc, 0x98, 0xd8, 0x8b, 0x3a, 0x0b, 0x2f,
-       0xb7, 0xe0, 0xf5, 0xf5, 0x36, 0x63, 0xfe, 0x5a,
-       0x00, 0x0c, 0x99, 0xe4, 0xf1, 0x6a, 0xae, 0xba,
-       0x9b, 0xe7, 0x59, 0x00, 0x67, 0x7c, 0xbe, 0x3c,
-       0x01, 0x94, 0xb4, 0x7b, 0x78, 0x0a, 0x90, 0x8d,
-       0x35, 0xe5, 0x8a, 0x55, 0xc4, 0x16, 0x88, 0x46,
-       0x15, 0xa3, 0x08, 0xd1, 0xd5, 0x6c, 0x9f, 0xcb,
-       0x5f, 0xf8, 0xc7, 0x9e, 0x86, 0xc7, 0xc0, 0x97,
-       0xe3, 0xbf, 0xc9, 0xdf, 0xe7, 0xc6, 0xff, 0x07,
-       0xe5, 0x7d, 0x4e, 0xfa, 0xeb, 0x49, 0x51, 0x08,
-       0xea, 0xac, 0x36, 0xc8, 0x91, 0xb3, 0xfc, 0xdd,
-       0x36, 0x5c, 0x95, 0xcf, 0xa6, 0xfb, 0x0b, 0x1e,
-       0x65, 0x5c, 0x50, 0x8f, 0x70, 0xa1, 0x92, 0x1a,
-       0x34, 0xd2, 0x9d, 0x27, 0xc5, 0xea, 0x1e, 0xd0,
-       0x25, 0x49, 0xe0, 0x5f, 0x2f, 0x02, 0x0c, 0x8e,
-       0x41, 0xfb, 0x9a, 0x82, 0xab, 0xfe, 0xb9, 0x0b,
-       0x96, 0x81, 0xef, 0x69, 0xc5, 0x5b, 0x36, 0xa0,
-       0x77, 0x95, 0x0c, 0xe8, 0x76, 0xa5, 0x8e, 0xc5,
-       0x75, 0xd6, 0xfb, 0xc8, 0x39, 0x9a, 0x9e, 0xfd,
-       0x09, 0xb7, 0xd1, 0x73, 0xc4, 0xc5, 0x33, 0x76,
-       0x15, 0x83, 0x4e, 0xc6, 0x3e, 0xaf, 0x1b, 0x89,
-       0xd4, 0x72, 0xf1, 0x04, 0xe2, 0x7a, 0x86, 0xe3,
-       0xca, 0xcd, 0x5f, 0x28, 0x1e, 0x46, 0xab, 0xfd,
-       0x23, 0x86, 0xb2, 0xc5, 0x88, 0xc3, 0x85, 0xd4,
-       0x36, 0x94, 0x74, 0xa9, 0x6c, 0x40, 0xf7, 0x62,
-       0xdd, 0x06, 0xdf, 0x6d, 0x4a, 0xde, 0xab, 0xc7,
-       0xe5, 0x2b, 0x35, 0x8f, 0x2f, 0xea, 0x5e, 0xb4,
-       0x41, 0xe8, 0x03, 0x63, 0xc6, 0x79, 0x30, 0xa6,
-       0xe0, 0x6a, 0x59, 0xbe, 0x84, 0xa9, 0x4e, 0x49,
-       0x30, 0xef, 0x8a, 0x60, 0xa5, 0x5c, 0x16, 0x5d,
-       0xd4, 0xaf, 0x62, 0xcf, 0xe0, 0x2f, 0x8b, 0x4b,
-       0x04, 0x2b, 0xeb, 0x73, 0x29, 0xda, 0xf3, 0x70,
-       0xe4, 0xec, 0x43, 0xce, 0x23, 0xa2, 0x47, 0x82,
-       0xdc, 0x0b, 0x98, 0xc3, 0x66, 0xcc, 0xc1, 0x8c,
-       0x39, 0x78, 0x03, 0xa3, 0x70, 0x5d, 0x97, 0xea,
-       0xef, 0xae, 0x7b, 0xbc, 0x6e, 0x03, 0xae, 0x53,
-       0x2e, 0x23, 0xe7, 0xff, 0x42, 0xce, 0xed, 0xa2,
-       0xdd, 0xf6, 0x1a, 0x8c, 0x4d, 0x7f, 0x22, 0x63,
-       0x33, 0x52, 0x1a, 0x90, 0xb2, 0x11, 0xfd, 0x93,
-       0x15, 0x73, 0xe9, 0x16, 0xe1, 0x77, 0x6b, 0xa0,
-       0xa2, 0xb5, 0xb5, 0x49, 0x91, 0x5a, 0x85, 0x8e,
-       0x96, 0xd5, 0x4d, 0x42, 0x47, 0xa0, 0xa9, 0xa1,
-       0x45, 0x6e, 0x69, 0x0a, 0x0a, 0x13, 0x05, 0x47,
-       0x7b, 0x5b, 0xeb, 0x2a, 0x21, 0xa7, 0x5e, 0xc8,
-       0x79, 0x58, 0xc8, 0x69, 0x15, 0xa4, 0xd6, 0xd6,
-       0xf6, 0x87, 0x9b, 0x1a, 0x27, 0x5b, 0x60, 0x4e,
-       0xd3, 0xf2, 0xf6, 0xe0, 0x2a, 0xe1, 0x61, 0x29,
-       0xd4, 0xd0, 0xcc, 0xdd, 0x55, 0x4e, 0xbd, 0x05,
-       0x72, 0x1e, 0xc6, 0x5f, 0xeb, 0x75, 0xb1, 0x1d,
-       0x4d, 0x21, 0xce, 0x31, 0x8c, 0x1a, 0x44, 0x64,
-       0x45, 0x93, 0xea, 0xea, 0x6a, 0xdb, 0xdb, 0x05,
-       0x5c, 0xab, 0xac, 0x12, 0x96, 0xc7, 0xb3, 0x60,
-       0x3f, 0x75, 0x37, 0x36, 0x06, 0x9b, 0x3a, 0x3a,
-       0x84, 0xe5, 0x9d, 0xe8, 0x1b, 0xeb, 0x9b, 0x84,
-       0xa6, 0x15, 0x4d, 0x6d, 0xb1, 0x62, 0xa1, 0x33,
-       0x2f, 0x2c, 0x72, 0x3a, 0x9d, 0x42, 0x20, 0xd8,
-       0xde, 0x80, 0x5c, 0xed, 0xc1, 0xc9, 0x96, 0xff,
-       0x9f, 0xef, 0xf4, 0xf3, 0x7e, 0x0c, 0xfd, 0xb4,
-       0x9a, 0xcf, 0x39, 0xa2, 0x14, 0xb8, 0x07, 0xa2,
-       0x27, 0x4b, 0x06, 0xa2, 0xd5, 0x65, 0x03, 0xd1,
-       0x8d, 0x3e, 0xbb, 0x62, 0xca, 0x5c, 0x94, 0xf1,
-       0x0b, 0xf1, 0x0a, 0x7f, 0xbe, 0x0c, 0xab, 0xc2,
-       0xc0, 0x76, 0x27, 0xa9, 0x3b, 0x51, 0x68, 0x0f,
-       0xcd, 0x54, 0x07, 0x64, 0x54, 0x9e, 0x1a, 0xa5,
-       0x3e, 0xdf, 0x41, 0x6f, 0xd9, 0x8f, 0x12, 0xb6,
-       0xa2, 0x84, 0x64, 0x94, 0xe0, 0x0b, 0x40, 0xdd,
-       0x06, 0x5c, 0x1b, 0x97, 0x67, 0x2e, 0xaa, 0x01,
-       0xd9, 0x9c, 0x32, 0x66, 0x67, 0x8a, 0x72, 0x51,
-       0x4c, 0xa1, 0x70, 0xde, 0x98, 0x9d, 0x7e, 0xe5,
-       0x8c, 0x68, 0x4a, 0x1f, 0xb3, 0x73, 0x93, 0x72,
-       0x62, 0xd2, 0x5b, 0x98, 0xfb, 0xfb, 0x7c, 0x1f,
-       0xc5, 0xc4, 0x55, 0x24, 0x9b, 0x49, 0x35, 0xe8,
-       0x17, 0x3e, 0x12, 0xc5, 0xd1, 0x74, 0x5b, 0xce,
-       0xbf, 0x8b, 0x70, 0xa2, 0x98, 0x28, 0xb4, 0x13,
-       0x86, 0x3d, 0xa5, 0x08, 0xb3, 0x12, 0xff, 0xbb,
-       0x42, 0x23, 0x2f, 0x42, 0xb4, 0xa0, 0x34, 0xec,
-       0x29, 0x55, 0xc2, 0xb4, 0x68, 0x0e, 0x59, 0xea,
-       0xc2, 0x52, 0xee, 0x97, 0x17, 0x52, 0xa3, 0x61,
-       0x8b, 0xaa, 0x6d, 0xd8, 0xd0, 0x2c, 0xb5, 0x29,
-       0x5a, 0x03, 0xbb, 0x07, 0xae, 0xf5, 0x07, 0x46,
-       0x79, 0xec, 0xb4, 0x76, 0xe6, 0x33, 0x80, 0xb9,
-       0xc9, 0x22, 0x7c, 0x62, 0x74, 0xb7, 0xb6, 0x0e,
-       0x6f, 0xf3, 0xc6, 0xa6, 0xd6, 0xa6, 0x50, 0x53,
-       0xa3, 0x05, 0xc7, 0xa3, 0xd9, 0x87, 0x65, 0x98,
-       0xc5, 0x46, 0x28, 0xef, 0x46, 0xc4, 0xf6, 0xca,
-       0x50, 0x3e, 0xc8, 0xb0, 0xcd, 0x95, 0x9f, 0xb2,
-       0xe7, 0x86, 0x1b, 0x77, 0x86, 0xdb, 0xa1, 0xbc,
-       0x8f, 0xbc, 0xa4, 0x77, 0x8b, 0x04, 0xb3, 0x9a,
-       0x7d, 0xa3, 0x15, 0x28, 0xbf, 0x6c, 0x1b, 0xad,
-       0x60, 0xa9, 0x66, 0x65, 0xa4, 0x44, 0xc4, 0xcb,
-       0x95, 0x9f, 0x1a, 0x80, 0x38, 0xc9, 0xa7, 0x7b,
-       0xd3, 0x33, 0xf9, 0x93, 0xf8, 0xef, 0xa0, 0xc7,
-       0x7e, 0xb9, 0x8c, 0xa5, 0x4a, 0x19, 0x8b, 0x23,
-       0x29, 0xc0, 0x73, 0x99, 0xdd, 0x0e, 0xef, 0xab,
-       0xb4, 0xb3, 0x1d, 0x9a, 0x92, 0xad, 0xaf, 0xd2,
-       0xfe, 0x2f, 0x7a, 0xd6, 0xa6, 0xa4, 0x88, 0x56,
-       0x2b, 0x3d, 0x27, 0xe1, 0x98, 0x11, 0x57, 0xe6,
-       0x6b, 0x6c, 0xd8, 0xbb, 0x24, 0x28, 0x3f, 0xb8,
-       0x13, 0xe4, 0x03, 0x39, 0xe6, 0x94, 0xb1, 0xca,
-       0x0c, 0x94, 0xf0, 0xe0, 0x97, 0x4c, 0xed, 0x42,
-       0x8f, 0x94, 0x8a, 0xa9, 0xbb, 0x77, 0x82, 0x72,
-       0x40, 0x98, 0x85, 0xfe, 0x3a, 0x20, 0x24, 0xd6,
-       0xb0, 0x7b, 0x8b, 0xb3, 0x52, 0x72, 0xbb, 0x04,
-       0x01, 0xcc, 0x1e, 0x07, 0x58, 0x48, 0xab, 0x0b,
-       0xea, 0x24, 0x98, 0x73, 0x9e, 0xf1, 0x54, 0xb2,
-       0x7e, 0xbf, 0x12, 0x67, 0x19, 0xd8, 0x3e, 0xf3,
-       0x64, 0xa4, 0x1f, 0x15, 0xe1, 0xb7, 0x87, 0x50,
-       0x8f, 0x4b, 0x30, 0x7c, 0x50, 0x82, 0x0f, 0x36,
-       0x60, 0xf8, 0x5f, 0x31, 0xfc, 0x1a, 0x7a, 0xb6,
-       0x55, 0xb2, 0x4b, 0x82, 0x5f, 0x2d, 0x71, 0x5f,
-       0x05, 0x1c, 0xd5, 0x83, 0x51, 0x21, 0x32, 0xfc,
-       0xdf, 0xbc, 0x37, 0xa3, 0x17, 0x31, 0x7e, 0x93,
-       0xf6, 0x4c, 0x90, 0xed, 0x5d, 0xbb, 0x92, 0x8f,
-       0x16, 0x45, 0xf6, 0xc6, 0x9f, 0x9f, 0xa2, 0xf4,
-       0xa5, 0xf1, 0x2d, 0xd3, 0x82, 0x61, 0xec, 0x7c,
-       0x0d, 0xad, 0x4d, 0x52, 0x90, 0x5a, 0x14, 0x07,
-       0xd5, 0x50, 0x73, 0x13, 0xf6, 0xd8, 0x86, 0xe6,
-       0x96, 0xb6, 0x26, 0x1e, 0x1f, 0x6c, 0xaa, 0x6f,
-       0x6f, 0x0f, 0x4d, 0xb4, 0x38, 0x16, 0xb5, 0x77,
-       0x72, 0x4a, 0xb3, 0xb4, 0xa2, 0x49, 0x08, 0xb5,
-       0x63, 0x4c, 0x4b, 0x5b, 0x47, 0x08, 0x5d, 0x87,
-       0xfa, 0x06, 0xc6, 0x64, 0x8b, 0x3b, 0xd8, 0x24,
-       0xac, 0x42, 0xb6, 0x8e, 0x4e, 0x35, 0xf0, 0xb0,
-       0xd4, 0x16, 0x22, 0xd6, 0x86, 0xf6, 0xb6, 0x50,
-       0x4b, 0x5b, 0x67, 0x93, 0x30, 0x53, 0x70, 0xac,
-       0x9a, 0xda, 0x36, 0x79, 0x24, 0x7c, 0xe9, 0x07,
-       0xb3, 0x23, 0xd9, 0x2e, 0x9b, 0x59, 0x29, 0x12,
-       0x94, 0x89, 0x64, 0x07, 0xf0, 0x0c, 0xd7, 0x2a,
-       0xcd, 0x1f, 0xcb, 0xec, 0xb6, 0x88, 0xcf, 0x26,
-       0x5f, 0xe6, 0x14, 0xeb, 0xc6, 0xf9, 0xb8, 0xc8,
-       0x95, 0x53, 0x71, 0x86, 0xb2, 0xdd, 0xda, 0x4f,
-       0x77, 0xb8, 0x47, 0xd6, 0x65, 0xd0, 0x35, 0x22,
-       0x3e, 0x68, 0xad, 0x2e, 0xf1, 0xca, 0x63, 0x7d,
-       0x0e, 0xf4, 0xe7, 0x2c, 0x7e, 0xc4, 0x1e, 0x8a,
-       0xb7, 0x0a, 0x14, 0x6f, 0xed, 0x16, 0x67, 0x58,
-       0x71, 0xe6, 0xcb, 0x63, 0x92, 0x1d, 0x14, 0x93,
-       0xbc, 0x91, 0x62, 0x92, 0xaf, 0x8a, 0x19, 0x56,
-       0x5c, 0x4e, 0xf1, 0x98, 0x51, 0x22, 0xc5, 0x8c,
-       0x3a, 0x44, 0x31, 0x36, 0xa7, 0x48, 0xde, 0x7a,
-       0x81, 0x04, 0x95, 0xe3, 0x45, 0xb3, 0xf6, 0xa6,
-       0x02, 0x52, 0xee, 0x47, 0x8a, 0x95, 0xed, 0xf3,
-       0xca, 0xeb, 0xd9, 0x4b, 0xe5, 0x90, 0x69, 0xfe,
-       0xba, 0x88, 0xc2, 0x23, 0xf6, 0xb0, 0xb0, 0x9f,
-       0xc2, 0xc9, 0x0e, 0x16, 0xf6, 0x51, 0x78, 0x94,
-       0xc8, 0xc2, 0x6e, 0xec, 0x0b, 0xd8, 0xfe, 0xbf,
-       0x39, 0xa4, 0x39, 0xed, 0x65, 0x4d, 0xab, 0x96,
-       0x4b, 0x01, 0xa1, 0x4d, 0x5a, 0xde, 0xc4, 0x5c,
-       0x66, 0x43, 0xa8, 0x73, 0x88, 0xda, 0xd2, 0x21,
-       0x4c, 0x13, 0x00, 0x2b, 0x8c, 0xd3, 0x4c, 0xaf,
-       0x05, 0x4a, 0x2d, 0x50, 0x6e, 0x81, 0x10, 0xfc,
-       0xed, 0xe1, 0x22, 0x76, 0x87, 0x6e, 0x0b, 0xbb,
-       0x1b, 0x3e, 0xcd, 0xa8, 0xf6, 0x0b, 0x51, 0x60,
-       0x7b, 0xbb, 0x72, 0x9c, 0x55, 0xaf, 0xc2, 0xf6,
-       0xbc, 0xae, 0x4c, 0x50, 0x4a, 0xc9, 0xe6, 0xf2,
-       0xcf, 0x61, 0x9e, 0x0f, 0x0a, 0x29, 0x64, 0x97,
-       0x35, 0x2e, 0x46, 0xf9, 0x08, 0x29, 0x95, 0x82,
-       0x25, 0xa8, 0x47, 0x4a, 0x0e, 0xa3, 0xfc, 0x1a,
-       0x29, 0xd3, 0x84, 0x12, 0xbc, 0x16, 0xd0, 0x7d,
-       0xaa, 0xb7, 0x66, 0xd4, 0x94, 0xca, 0xa6, 0xa2,
-       0x04, 0x09, 0xde, 0xbf, 0xe0, 0xf7, 0xd4, 0x6d,
-       0xd8, 0xd5, 0x05, 0x2e, 0x79, 0x0b, 0x96, 0xdb,
-       0x86, 0x05, 0xca, 0xa0, 0xf7, 0x75, 0xb4, 0xf6,
-       0x2a, 0xe9, 0xa1, 0xf6, 0x2a, 0xc9, 0x91, 0x20,
-       0xdd, 0x27, 0x2f, 0x20, 0xdd, 0xcd, 0x4a, 0x09,
-       0xe1, 0x0a, 0xa0, 0x79, 0x77, 0x0e, 0x28, 0xe5,
-       0xf9, 0x83, 0x6c, 0x67, 0xde, 0x92, 0xd5, 0x50,
-       0x5c, 0x0c, 0xff, 0x53, 0xe8, 0x82, 0x7f, 0x58,
-       0xb3, 0x44, 0x48, 0x08, 0x8e, 0xc0, 0x1e, 0xb2,
-       0x59, 0x76, 0x9c, 0x58, 0x9b, 0x9e, 0x88, 0x7a,
-       0x46, 0x5a, 0x66, 0x31, 0x40, 0x1a, 0x7a, 0x8d,
-       0xd6, 0x42, 0xf5, 0xf9, 0xd8, 0x77, 0x64, 0xe3,
-       0xbc, 0xb7, 0xa3, 0xbd, 0xe9, 0x89, 0x12, 0x2c,
-       0xdd, 0x2c, 0xc2, 0x85, 0x2d, 0xb1, 0xfc, 0x5c,
-       0x94, 0x9f, 0xe7, 0x75, 0x09, 0x26, 0x9e, 0x90,
-       0x5b, 0xd5, 0xfc, 0x30, 0x65, 0x73, 0x39, 0xe6,
-       0xb7, 0x44, 0x98, 0x65, 0xdd, 0x01, 0x23, 0x23,
-       0x00, 0xa9, 0x6c, 0x56, 0xef, 0x97, 0xc0, 0xd7,
-       0x28, 0x5e, 0x57, 0x8a, 0xeb, 0xf3, 0x5c, 0xda,
-       0x2d, 0x67, 0xc4, 0x97, 0x6c, 0xfe, 0x31, 0x39,
-       0xf5, 0xc4, 0xda, 0x1b, 0x4a, 0x81, 0x1e, 0xef,
-       0x42, 0xca, 0xc2, 0x60, 0x7b, 0x9b, 0x82, 0x13,
-       0xd3, 0xd6, 0x26, 0x3e, 0xda, 0x62, 0x8b, 0xa1,
-       0x84, 0xf2, 0xf7, 0xe5, 0x1c, 0x6c, 0x63, 0x74,
-       0x1d, 0xad, 0xe0, 0x49, 0xe3, 0xb3, 0x4a, 0x4f,
-       0x32, 0xf3, 0x76, 0x75, 0x99, 0x14, 0xff, 0xba,
-       0x9c, 0xcc, 0xe7, 0xa5, 0xf7, 0x84, 0x8b, 0x40,
-       0x84, 0x5f, 0x1f, 0xce, 0xa2, 0xa7, 0xb4, 0x75,
-       0x6b, 0x12, 0x5f, 0xe3, 0xa9, 0x52, 0xa4, 0xb1,
-       0xb5, 0xdf, 0xd4, 0xf6, 0x70, 0x54, 0xec, 0x9c,
-       0xf7, 0x4e, 0xb4, 0x6f, 0xd2, 0x4f, 0x89, 0x03,
-       0x79, 0x9f, 0xa5, 0xd9, 0x2e, 0xf9, 0xbb, 0xc2,
-       0x1e, 0x2e, 0x83, 0xf3, 0x39, 0x07, 0x9b, 0x04,
-       0xdb, 0x20, 0x64, 0x04, 0x0d, 0x4e, 0x6c, 0xa5,
-       0x79, 0x7d, 0xef, 0xee, 0x73, 0x0e, 0x0a, 0x19,
-       0xce, 0xfc, 0x6a, 0x08, 0xa2, 0xaf, 0x9a, 0x77,
-       0xfc, 0xdd, 0x7d, 0xc2, 0xa0, 0x20, 0xdc, 0x27,
-       0x7c, 0x38, 0xa7, 0xe2, 0x52, 0x35, 0x08, 0x27,
-       0x85, 0x93, 0xce, 0x41, 0x0b, 0xf0, 0x39, 0x32,
-       0xbf, 0x4f, 0xeb, 0xee, 0x83, 0x6a, 0x6b, 0x75,
-       0x93, 0x20, 0x8f, 0xaf, 0x25, 0x9f, 0x38, 0x76,
-       0x7e, 0x78, 0x59, 0x6a, 0x16, 0x48, 0x1b, 0x63,
-       0xe5, 0xc8, 0xa2, 0x3b, 0xb4, 0xf4, 0x46, 0x0e,
-       0xe7, 0x9f, 0x0a, 0x6c, 0x97, 0x4a, 0xe9, 0x7c,
-       0x17, 0xbf, 0xa7, 0x2a, 0x4c, 0x60, 0xa9, 0x73,
-       0x28, 0x75, 0xd9, 0xc9, 0xda, 0xb0, 0xaa, 0x81,
-       0xf1, 0x28, 0x03, 0xbd, 0x5e, 0xed, 0x37, 0x79,
-       0x0d, 0x48, 0x86, 0x26, 0xd1, 0x7b, 0x9c, 0xa4,
-       0x69, 0x2d, 0xe9, 0x5e, 0x41, 0x2d, 0xe9, 0xba,
-       0xcc, 0xdb, 0x50, 0x82, 0xe0, 0x83, 0x22, 0x9c,
-       0xef, 0xa1, 0x3e, 0xe8, 0x13, 0xb1, 0xed, 0xba,
-       0x90, 0x7f, 0x07, 0xce, 0xc0, 0x2e, 0x40, 0x5a,
-       0x09, 0x4b, 0x9f, 0x51, 0x11, 0x48, 0x1c, 0x7a,
-       0x72, 0x10, 0xc0, 0x15, 0xa7, 0xa8, 0x4f, 0x39,
-       0xae, 0x8e, 0x49, 0x7f, 0x8f, 0xdc, 0xab, 0x79,
-       0x3e, 0xe8, 0x83, 0xd1, 0x6b, 0x78, 0x5b, 0x91,
-       0xfa, 0x5d, 0xeb, 0x4b, 0xb0, 0xed, 0x6f, 0xdb,
-       0xc0, 0xaa, 0x50, 0xdf, 0xc3, 0x51, 0xc6, 0xbb,
-       0x40, 0xc8, 0x06, 0x23, 0xf5, 0x84, 0xea, 0x66,
-       0xa4, 0x2c, 0x43, 0x4a, 0x29, 0x52, 0xcc, 0x8c,
-       0xb2, 0x5a, 0x48, 0x95, 0x9f, 0xc4, 0x32, 0x64,
-       0x4f, 0x99, 0x32, 0x45, 0xa8, 0xa2, 0x0e, 0x39,
-       0x65, 0xe8, 0x0f, 0xc3, 0x42, 0x69, 0xd3, 0x8a,
-       0x96, 0x06, 0xa2, 0xd2, 0xff, 0xf2, 0x96, 0x20,
-       0xce, 0x6a, 0x3c, 0xad, 0xed, 0x0d, 0xcb, 0x84,
-       0x18, 0x47, 0x55, 0x3d, 0x23, 0x74, 0xc4, 0x52,
-       0x5a, 0xb8, 0x0f, 0x8c, 0xf7, 0x84, 0x2c, 0x5c,
-       0x51, 0x5a, 0x16, 0x8f, 0x96, 0xb7, 0xe2, 0x2a,
-       0x72, 0x15, 0x43, 0x81, 0xef, 0xe9, 0x92, 0x71,
-       0x86, 0x0b, 0x3b, 0x70, 0x24, 0x7c, 0x5e, 0x84,
-       0x73, 0x5b, 0xd5, 0x77, 0xc7, 0xc8, 0xa6, 0x5f,
-       0x40, 0xda, 0x46, 0x71, 0x2c, 0xdf, 0xbb, 0xcf,
-       0x28, 0xaf, 0x22, 0x65, 0x0d, 0xed, 0xbe, 0x84,
-       0xc3, 0x18, 0x0a, 0x51, 0x7f, 0xde, 0x69, 0xa3,
-       0x51, 0xc7, 0x57, 0xad, 0xa4, 0x05, 0xb1, 0x35,
-       0x44, 0x41, 0x4e, 0xc6, 0x79, 0xe6, 0x1a, 0x8c,
-       0x45, 0x5f, 0x06, 0x11, 0xe2, 0xd5, 0x61, 0xab,
-       0xcd, 0xf2, 0xc6, 0xf1, 0xd6, 0x21, 0x2f, 0xce,
-       0x80, 0x1f, 0xba, 0xcc, 0x78, 0xd7, 0x62, 0x6c,
-       0x16, 0xf2, 0x6e, 0x66, 0xbc, 0xdf, 0x46, 0x6c,
-       0x1c, 0x8e, 0x47, 0xa0, 0x4a, 0xb5, 0xf0, 0x74,
-       0x12, 0x5a, 0x8b, 0x08, 0x7d, 0x83, 0x55, 0xed,
-       0xac, 0x3e, 0x6c, 0x8d, 0x26, 0x4b, 0x0d, 0x4d,
-       0x16, 0x28, 0xab, 0xac, 0x71, 0xd7, 0x0a, 0x25,
-       0xa5, 0xf9, 0x79, 0x42, 0x75, 0xb0, 0x5d, 0x98,
-       0xd3, 0xde, 0xd8, 0x89, 0x5d, 0xe6, 0x3a, 0xa6,
-       0x59, 0xd2, 0x2a, 0x24, 0xba, 0x73, 0xf3, 0x70,
-       0x12, 0x78, 0xf3, 0xa8, 0x02, 0xe7, 0x8d, 0x51,
-       0x50, 0xc1, 0xf2, 0xc6, 0x52, 0xe1, 0x0c, 0xb8,
-       0x7c, 0x3d, 0xda, 0x47, 0xe1, 0xbd, 0x5d, 0x48,
-       0x5e, 0xe2, 0xab, 0x26, 0x0f, 0xab, 0x2b, 0x47,
-       0x6a, 0x00, 0x75, 0x81, 0xab, 0xfe, 0xf2, 0x66,
-       0x8c, 0x4d, 0x65, 0xb1, 0x99, 0x6a, 0xac, 0xc3,
-       0x6a, 0x47, 0xad, 0x0d, 0xd4, 0x74, 0xa7, 0x7b,
-       0x7d, 0xb7, 0xc9, 0x83, 0x63, 0xba, 0xc0, 0x42,
-       0xf7, 0x07, 0xca, 0x67, 0x60, 0x8a, 0x93, 0x08,
-       0x0b, 0x9d, 0xd9, 0xa0, 0xa7, 0x1e, 0x54, 0x45,
-       0xf6, 0x73, 0x02, 0x29, 0x19, 0x48, 0x31, 0x31,
-       0xca, 0x62, 0xa4, 0x1c, 0x47, 0x4a, 0x0a, 0x52,
-       0xac, 0x8c, 0xe2, 0x45, 0xca, 0xbf, 0x21, 0x05,
-       0x82, 0x09, 0xc4, 0x15, 0xb9, 0x00, 0x56, 0xfc,
-       0xe9, 0x83, 0x23, 0xce, 0xec, 0x60, 0xf1, 0x64,
-       0x75, 0x6f, 0x61, 0xef, 0x38, 0x5d, 0xd5, 0x49,
-       0xe6, 0x13, 0x6c, 0xc1, 0x31, 0xd5, 0x89, 0x8d,
-       0x3c, 0x0d, 0x27, 0xbd, 0x4d, 0x1d, 0x4d, 0x6d,
-       0x21, 0x0b, 0x5c, 0x47, 0x97, 0xea, 0xaf, 0x23,
-       0xe7, 0x7e, 0x0e, 0x7b, 0xee, 0x30, 0x76, 0x44,
-       0x98, 0xc1, 0xb2, 0xbf, 0x69, 0xcc, 0xa6, 0x6a,
-       0x9a, 0x82, 0x2d, 0x38, 0x92, 0xb4, 0xb5, 0xab,
-       0x78, 0xc9, 0xaa, 0x56, 0x5c, 0x4f, 0x37, 0x05,
-       0x3b, 0x54, 0xdc, 0xdb, 0x24, 0x35, 0x76, 0x0c,
-       0xe3, 0x6f, 0x08, 0xb5, 0x07, 0x3b, 0x38, 0x5e,
-       0x35, 0xd5, 0xcd, 0x84, 0x96, 0x48, 0x01, 0xa9,
-       0xa1, 0x25, 0xb4, 0x8a, 0x11, 0x1d, 0x73, 0x3c,
-       0x34, 0x45, 0xd7, 0xfa, 0xef, 0xf4, 0xdd, 0xd4,
-       0x7f, 0xa7, 0x17, 0x94, 0xa8, 0xbd, 0x7b, 0xfa,
-       0x0b, 0x0c, 0xcf, 0x90, 0xe0, 0xc4, 0x33, 0x5d,
-       0xb0, 0x06, 0x86, 0x7c, 0x73, 0xfd, 0x8b, 0xd9,
-       0x40, 0x63, 0x3a, 0x51, 0xca, 0x23, 0x34, 0x3a,
-       0xd4, 0x6f, 0xc9, 0x01, 0xb9, 0xca, 0xba, 0x0a,
-       0x92, 0xd0, 0x9e, 0xbc, 0xf4, 0x34, 0x95, 0x76,
-       0xd8, 0xf9, 0xbc, 0xbc, 0x07, 0xfb, 0xec, 0xf2,
-       0x60, 0x4d, 0xb7, 0xd5, 0x01, 0xd3, 0x68, 0x5d,
-       0x8c, 0x5e, 0x6e, 0x6a, 0x7a, 0x79, 0xc9, 0x39,
-       0x40, 0x0b, 0xb4, 0xdd, 0x26, 0xea, 0xf9, 0x33,
-       0x1c, 0x8f, 0x2d, 0x4e, 0x9a, 0x0f, 0x7d, 0x7f,
-       0xb1, 0x50, 0x9e, 0xe5, 0x40, 0xbf, 0x5f, 0xa0,
-       0x79, 0x7b, 0xf2, 0xef, 0x61, 0x78, 0xed, 0xd1,
-       0x56, 0x7d, 0x66, 0xc2, 0xd6, 0x47, 0xd3, 0x4d,
-       0xdc, 0xeb, 0x4b, 0xd0, 0xb8, 0xc5, 0x17, 0x96,
-       0x93, 0xc9, 0xa7, 0x37, 0x1d, 0xc2, 0x90, 0xd1,
-       0xf7, 0x4d, 0xf9, 0x58, 0xba, 0x89, 0x66, 0x78,
-       0x8d, 0x59, 0xe9, 0x89, 0x0c, 0xa6, 0x63, 0x1d,
-       0x72, 0x44, 0xf8, 0x08, 0xa1, 0x5b, 0x8f, 0x23,
-       0x52, 0x58, 0xe1, 0xde, 0x3c, 0x9b, 0x5d, 0x1d,
-       0x62, 0x51, 0x06, 0xf9, 0xef, 0x6c, 0xb6, 0xd7,
-       0xc6, 0x41, 0x7b, 0xb5, 0xbc, 0xd9, 0xec, 0xea,
-       0xa0, 0x7e, 0x71, 0x9f, 0x03, 0x47, 0xa9, 0x8b,
-       0xe4, 0x51, 0x66, 0x1f, 0x65, 0xf8, 0x74, 0xc4,
-       0xdf, 0x17, 0x70, 0xac, 0x9d, 0x7d, 0x5c, 0x84,
-       0x0f, 0xdf, 0x9e, 0xdb, 0x19, 0x0a, 0x74, 0x86,
-       0xb4, 0xe9, 0x99, 0x1c, 0x6c, 0x5f, 0x4e, 0x23,
-       0x2a, 0xce, 0x9f, 0x32, 0x68, 0x2c, 0x71, 0x6d,
-       0x92, 0xe1, 0x3e, 0xf6, 0xee, 0x8f, 0xd7, 0x89,
-       0xd8, 0x63, 0x88, 0x1d, 0x60, 0x58, 0xc1, 0x46,
-       0xca, 0xc1, 0xd9, 0x0e, 0xf7, 0xed, 0x42, 0x7a,
-       0x2b, 0xd2, 0x5f, 0x62, 0xf4, 0x22, 0x09, 0x7e,
-       0x99, 0x1d, 0x80, 0x29, 0x2e, 0x1d, 0xed, 0x50,
-       0x43, 0x0e, 0x7a, 0x02, 0xe8, 0x2d, 0xa2, 0x27,
-       0x99, 0xde, 0x82, 0x40, 0xf4, 0x95, 0xc3, 0xad,
-       0xe6, 0x1f, 0x98, 0x95, 0xab, 0x82, 0xb9, 0x26,
-       0x8c, 0x9c, 0x75, 0xc1, 0x68, 0xcf, 0x5a, 0x85,
-       0xf9, 0xbb, 0xd9, 0x3e, 0x91, 0xf5, 0xe3, 0xfb,
-       0xf6, 0x63, 0xf9, 0x66, 0x60, 0xc9, 0x0a, 0xca,
-       0xbe, 0x4e, 0x73, 0x0f, 0x9c, 0x25, 0x4a, 0x1d,
-       0x39, 0x16, 0xc8, 0xf4, 0x62, 0x3e, 0x46, 0x79,
-       0x1c, 0x1f, 0xcf, 0xee, 0x9b, 0x91, 0xee, 0x9a,
-       0xf4, 0x26, 0xca, 0x2c, 0xd6, 0x7a, 0x10, 0xce,
-       0xc9, 0x4c, 0xc2, 0x6c, 0x11, 0x26, 0x1f, 0xa4,
-       0x19, 0xc3, 0x95, 0x13, 0xa8, 0x4b, 0x98, 0x76,
-       0x91, 0x5a, 0x70, 0x84, 0x8b, 0xd6, 0x41, 0xde,
-       0x62, 0x09, 0x26, 0xd1, 0xbb, 0x45, 0xdb, 0x47,
-       0xcc, 0x28, 0x62, 0x7e, 0x5a, 0xdd, 0x9d, 0x54,
-       0x1c, 0x82, 0x02, 0x46, 0x3d, 0xe6, 0xa9, 0x5d,
-       0xd7, 0xbb, 0x8e, 0xaf, 0x48, 0x3c, 0x7b, 0x71,
-       0xac, 0xde, 0x8e, 0xe1, 0x64, 0x0c, 0xf7, 0x88,
-       0x70, 0xf6, 0x05, 0x89, 0x4d, 0x34, 0xaa, 0xbe,
-       0x2e, 0xc1, 0xcc, 0x35, 0x28, 0xf9, 0x75, 0x56,
-       0xdb, 0xea, 0x74, 0xd4, 0xd1, 0xcc, 0x36, 0xc4,
-       0x5f, 0x66, 0x78, 0xed, 0xc6, 0xb5, 0xed, 0x30,
-       0x6d, 0x3b, 0x59, 0x4f, 0x05, 0xea, 0x7d, 0x66,
-       0xad, 0x04, 0xc7, 0xc7, 0xab, 0xeb, 0x86, 0x6a,
-       0x7a, 0x8e, 0x59, 0xe1, 0xd8, 0xd9, 0x05, 0x06,
-       0x25, 0x0d, 0xaf, 0x3a, 0xc5, 0x6c, 0x8b, 0xbc,
-       0xf2, 0xe6, 0xf2, 0x01, 0x31, 0xd9, 0xc9, 0xa1,
-       0x49, 0x60, 0x10, 0xd3, 0xb8, 0x30, 0xc7, 0x02,
-       0x33, 0xed, 0x48, 0xff, 0xc9, 0x69, 0x1d, 0x83,
-       0xdb, 0xff, 0xae, 0x18, 0x69, 0x02, 0xdb, 0xbb,
-       0x99, 0x9d, 0x3f, 0x88, 0x45, 0xd9, 0xfe, 0x77,
-       0x76, 0xa4, 0x24, 0xc7, 0x28, 0xc0, 0x29, 0xbf,
-       0x1a, 0xd4, 0x28, 0x86, 0xe7, 0x54, 0xca, 0x79,
-       0xad, 0x8f, 0x4c, 0xdb, 0x44, 0x7d, 0x62, 0x1a,
-       0x7a, 0xca, 0x19, 0xaf, 0xc9, 0x70, 0xef, 0x00,
-       0xfe, 0xae, 0x38, 0xb0, 0x06, 0x33, 0x5e, 0xc2,
-       0xd0, 0x05, 0xfc, 0xf5, 0x65, 0x42, 0x3a, 0x08,
-       0xc6, 0xa7, 0x1f, 0x6b, 0x87, 0x7b, 0xd1, 0xff,
-       0xfc, 0x6b, 0xfd, 0xd0, 0x0c, 0xea, 0xa1, 0x10,
-       0x5a, 0x75, 0x72, 0x86, 0x91, 0x2c, 0xb5, 0x61,
-       0x3c, 0x5d, 0xa5, 0x0d, 0xc8, 0xf1, 0x34, 0xca,
-       0xdf, 0x10, 0x93, 0x9f, 0x47, 0xf2, 0xef, 0xed,
-       0xd1, 0xc6, 0x50, 0xc5, 0x86, 0xb1, 0xad, 0xb1,
-       0xd8, 0x54, 0x16, 0xbb, 0xe9, 0xa9, 0x43, 0xe9,
-       0xab, 0xf8, 0x7d, 0xd1, 0x5f, 0x2f, 0xfd, 0xa2,
-       0xfd, 0xb0, 0xd5, 0x62, 0xfc, 0x7e, 0x58, 0x09,
-       0xde, 0x3b, 0x36, 0x54, 0x9a, 0x07, 0x3f, 0xc2,
-       0xd2, 0x80, 0xee, 0x79, 0xad, 0x77, 0xa1, 0x17,
-       0xc6, 0xde, 0xe4, 0xd8, 0xeb, 0xf6, 0xd7, 0x2c,
-       0xc0, 0x19, 0x95, 0x75, 0x05, 0xf6, 0x9b, 0xfa,
-       0x95, 0x32, 0xe8, 0xd6, 0xb1, 0xf9, 0xd5, 0xf6,
-       0x19, 0xbb, 0xa8, 0xff, 0x01, 0xae, 0x77, 0xea,
-       0xeb, 0x91, 0xda, 0xca, 0xa9, 0xdf, 0x2d, 0x26,
-       0xaa, 0x9e, 0x7c, 0x42, 0x25, 0x52, 0x17, 0x70,
-       0xea, 0xdf, 0xb1, 0xbe, 0x6a, 0x24, 0x6a, 0x21,
-       0x52, 0x5d, 0x2a, 0xb5, 0x78, 0x85, 0x80, 0x94,
-       0x0c, 0xa4, 0xe4, 0x70, 0x8a, 0x6f, 0xdc, 0x0a,
-       0xb4, 0xdb, 0xfa, 0x14, 0xa4, 0x8c, 0x13, 0x66,
-       0x09, 0xd5, 0x38, 0xd7, 0xdb, 0xb6, 0xe9, 0x30,
-       0x58, 0xd1, 0x7f, 0x5c, 0x49, 0x4f, 0x0c, 0x01,
-       0x4a, 0xb1, 0xf6, 0xa2, 0x14, 0xa9, 0x1f, 0x29,
-       0x03, 0xa4, 0x31, 0x11, 0xd7, 0x61, 0xab, 0xc6,
-       0x4a, 0x70, 0x2b, 0x7a, 0xf2, 0xf7, 0x96, 0xa0,
-       0xff, 0xbf, 0x05, 0x6d, 0x1a, 0x67, 0x85, 0xc7,
-       0xd2, 0x30, 0x8c, 0xb3, 0x78, 0x17, 0x8e, 0x16,
-       0xff, 0x72, 0x31, 0xb6, 0xae, 0x3c, 0x38, 0x54,
-       0xdf, 0x07, 0xae, 0x50, 0x7d, 0x61, 0x57, 0x5c,
-       0x3d, 0xf3, 0xb4, 0x7a, 0x4a, 0x1b, 0x91, 0x77,
-       0x2b, 0x2b, 0x13, 0xe6, 0x97, 0x89, 0x3d, 0x5b,
-       0x42, 0x0b, 0x85, 0x6e, 0xca, 0xf1, 0x21, 0x9c,
-       0x5b, 0xaf, 0xc4, 0x71, 0xfb, 0xd6, 0x66, 0x94,
-       0x7c, 0x1e, 0xed, 0xf9, 0x08, 0x5a, 0xe5, 0x69,
-       0x09, 0x7e, 0xf1, 0x3c, 0x86, 0x71, 0x26, 0x3e,
-       0xf3, 0x18, 0xd2, 0xbb, 0xd4, 0x1c, 0x6b, 0xe3,
-       0xf2, 0x5b, 0x8f, 0xf9, 0x95, 0xc6, 0xe5, 0x96,
-       0x1f, 0xcb, 0x2d, 0x5d, 0xce, 0x66, 0x79, 0xdd,
-       0xf6, 0x1c, 0xd5, 0xd0, 0x24, 0x52, 0x0d, 0x93,
-       0x65, 0xbb, 0x68, 0x53, 0xeb, 0x2c, 0x90, 0xdf,
-       0x10, 0x07, 0x65, 0x13, 0xcb, 0x1f, 0x35, 0xfe,
-       0x2f, 0x41, 0x11, 0x3e, 0x90, 0xab, 0x71, 0xc1,
-       0xd7, 0x41, 0x77, 0x4e, 0x3b, 0x9a, 0x82, 0x21,
-       0xa1, 0xb1, 0xa5, 0x63, 0x19, 0x0e, 0x1a, 0xb4,
-       0xfa, 0x0b, 0xb0, 0x9b, 0x32, 0x74, 0xc3, 0x06,
-       0x97, 0x19, 0x39, 0x23, 0xe1, 0x26, 0x8c, 0x79,
-       0x5f, 0x96, 0x31, 0xff, 0xa6, 0x8c, 0xff, 0x81,
-       0xad, 0xb9, 0x43, 0x2b, 0xc0, 0x7b, 0x1e, 0x24,
-       0xab, 0x2d, 0x3c, 0x39, 0x64, 0xb5, 0x7d, 0xbb,
-       0xbe, 0xc8, 0x6a, 0xe7, 0xbc, 0x38, 0xdc, 0x6a,
-       0x8f, 0x8d, 0x1f, 0xd2, 0xea, 0x12, 0x27, 0xb5,
-       0xa2, 0xfe, 0xc0, 0x4d, 0xac, 0xb6, 0x44, 0xd3,
-       0xef, 0x43, 0xfb, 0x65, 0xd0, 0x6f, 0xbf, 0xde,
-       0x6a, 0x1f, 0xc2, 0x1e, 0xaa, 0x7f, 0xe2, 0x7a,
-       0xab, 0x7d, 0xe8, 0x69, 0xa4, 0xae, 0xb8, 0xde,
-       0x6a, 0x1f, 0x42, 0xcf, 0xa7, 0x17, 0xe3, 0xad,
-       0xf6, 0x21, 0xf4, 0x50, 0xfa, 0xaa, 0x78, 0xab,
-       0x7d, 0x68, 0x09, 0x52, 0x8a, 0x87, 0x5b, 0xad,
-       0xee, 0xb0, 0xda, 0x82, 0xe0, 0x22, 0x8e, 0x69,
-       0xc8, 0x31, 0xd6, 0x7d, 0xd5, 0x65, 0xfe, 0xce,
-       0x9b, 0x38, 0x0b, 0x9e, 0xf0, 0x93, 0xab, 0x12,
-       0x14, 0x3b, 0xb2, 0x21, 0xd3, 0x84, 0xd8, 0xc8,
-       0xe9, 0x4b, 0x77, 0x87, 0x97, 0xeb, 0x33, 0xe1,
-       0x99, 0x47, 0x29, 0x0d, 0x72, 0x53, 0xfa, 0x0b,
-       0xd4, 0xe2, 0x0f, 0x84, 0x7c, 0xeb, 0xb1, 0x67,
-       0x66, 0x4b, 0xb0, 0x02, 0x6b, 0x9f, 0xda, 0x8f,
-       0xb6, 0x16, 0x74, 0x0f, 0x5c, 0xbb, 0x1b, 0x47,
-       0x64, 0xb4, 0xc1, 0x77, 0xb3, 0x31, 0x8c, 0x3e,
-       0x74, 0x3a, 0x8e, 0x7c, 0xbf, 0xd0, 0x56, 0x8a,
-       0xa0, 0xdb, 0x39, 0xa4, 0xa3, 0xfb, 0xad, 0xac,
-       0x67, 0x3f, 0x37, 0xa4, 0x9b, 0x92, 0x98, 0xa5,
-       0x3f, 0xf8, 0x02, 0xf2, 0xae, 0xe7, 0x25, 0x78,
-       0x74, 0x70, 0xa8, 0x04, 0x19, 0xac, 0x44, 0x18,
-       0xbf, 0x1e, 0xe3, 0x65, 0x2a, 0xc5, 0x92, 0x8b,
-       0x58, 0x8a, 0xa0, 0x04, 0x9d, 0x2f, 0x61, 0x19,
-       0x5a, 0x25, 0x38, 0x7a, 0xd1, 0x3d, 0xf0, 0x59,
-       0x2f, 0xd6, 0xe0, 0xac, 0x04, 0xbd, 0x3b, 0x30,
-       0xfc, 0x1b, 0x0c, 0xe3, 0xec, 0xe9, 0x68, 0x38,
-       0x56, 0x86, 0x9c, 0xa1, 0x32, 0x2c, 0xee, 0x66,
-       0x65, 0x18, 0x17, 0x57, 0x86, 0x98, 0xfd, 0x3f,
-       0x98, 0x8e, 0xbc, 0xfa, 0x4c, 0x13, 0xcb, 0x75,
-       0xec, 0x3e, 0x6c, 0x9b, 0x07, 0x6d, 0xd8, 0xdb,
-       0xfa, 0x59, 0xae, 0x2b, 0x31, 0xc7, 0x69, 0x12,
-       0x8c, 0x19, 0xe0, 0xf3, 0x07, 0x94, 0xbf, 0x02,
-       0xf3, 0x32, 0x61, 0x5e, 0x58, 0x86, 0x5e, 0x27,
-       0x86, 0x3b, 0x31, 0x2c, 0x22, 0xdd, 0x1c, 0xeb,
-       0xe5, 0xbb, 0x87, 0x66, 0x26, 0x8b, 0x6d, 0x98,
-       0xef, 0x5e, 0x9e, 0x2b, 0xe5, 0xc6, 0x65, 0xca,
-       0xcf, 0x5b, 0x37, 0x93, 0x85, 0xc8, 0xcf, 0xb0,
-       0x3c, 0xc1, 0xf4, 0xe4, 0x0a, 0x2c, 0xa3, 0x54,
-       0xfc, 0xd4, 0xa1, 0x92, 0xab, 0xd4, 0x52, 0xf7,
-       0xad, 0x88, 0x6f, 0xb7, 0x25, 0x5e, 0x71, 0x49,
-       0x3c, 0xfe, 0x40, 0x50, 0xf6, 0x53, 0x2b, 0x96,
-       0x5c, 0x65, 0x6f, 0x73, 0xb1, 0x76, 0x9c, 0x26,
-       0x66, 0x42, 0x16, 0xf0, 0x96, 0x7b, 0xc0, 0x2f,
-       0xe7, 0xd1, 0xfd, 0x1d, 0x55, 0x16, 0xce, 0x39,
-       0x32, 0x12, 0x8e, 0xed, 0xa5, 0xb4, 0xa5, 0xeb,
-       0x56, 0x50, 0x4f, 0x3e, 0x16, 0x2f, 0xed, 0xfe,
-       0xf3, 0x54, 0xa6, 0xfb, 0x37, 0x62, 0x4b, 0x3e,
-       0x23, 0xc2, 0xbf, 0x6f, 0xd4, 0x7a, 0x49, 0x41,
-       0x11, 0xf5, 0x92, 0xfc, 0xdd, 0x48, 0xcf, 0x19,
-       0xaa, 0xcf, 0x22, 0x17, 0xe9, 0xd1, 0x38, 0x8d,
-       0xd7, 0x48, 0xb3, 0x7a, 0x4d, 0x93, 0xf7, 0x3f,
-       0x2b, 0x83, 0x71, 0x3c, 0xdb, 0x69, 0x52, 0xcf,
-       0x6a, 0xb8, 0x40, 0x19, 0xcb, 0xee, 0x19, 0x71,
-       0xac, 0x84, 0xee, 0xaa, 0xd3, 0x7b, 0x7b, 0xf7,
-       0x39, 0x45, 0x30, 0xf4, 0x5f, 0xdf, 0x23, 0xee,
-       0x17, 0x65, 0x30, 0x9c, 0xbe, 0xbe, 0x47, 0xdc,
-       0xef, 0x43, 0xea, 0x61, 0xfe, 0x96, 0x52, 0x19,
-       0xdb, 0x0f, 0xed, 0x1e, 0x30, 0x9c, 0xa4, 0x37,
-       0xc6, 0x7c, 0x76, 0x45, 0x5f, 0xf0, 0x54, 0xed,
-       0xe3, 0xb5, 0xec, 0x5e, 0x36, 0xb6, 0xcf, 0xa9,
-       0xfe, 0xee, 0xa1, 0xf7, 0x54, 0x19, 0x0c, 0x5f,
-       0xdf, 0x93, 0x16, 0x0f, 0xa2, 0xb4, 0xae, 0xf8,
-       0x9e, 0xb4, 0xf8, 0x3c, 0x52, 0x96, 0xb2, 0x1a,
-       0xd0, 0xdd, 0xfb, 0x93, 0x6c, 0x7f, 0xf2, 0xb8,
-       0x8c, 0xca, 0x9b, 0x78, 0x04, 0xab, 0xe6, 0x11,
-       0x2a, 0xb6, 0xe4, 0x6d, 0xf2, 0x97, 0xb2, 0x9c,
-       0x7f, 0x1e, 0xed, 0xe3, 0x7e, 0x61, 0x78, 0xcf,
-       0xd3, 0x3f, 0xc7, 0xac, 0xa1, 0x9e, 0x46, 0x34,
-       0xde, 0xc6, 0x2e, 0x33, 0xe9, 0xfe, 0xa1, 0x3a,
-       0x55, 0xf7, 0xcc, 0xba, 0x17, 0xb7, 0x65, 0x17,
-       0x01, 0x2c, 0xd5, 0x97, 0xae, 0xaf, 0x5e, 0x2f,
-       0xb8, 0x05, 0x9c, 0x5d, 0x6e, 0xc4, 0x76, 0x2a,
-       0x7f, 0x3a, 0x0b, 0x9e, 0x09, 0x2b, 0x6c, 0x9c,
-       0x42, 0x8d, 0x5f, 0x41, 0x3b, 0xd3, 0xbb, 0x07,
-       0x06, 0x7e, 0x2c, 0xc1, 0xbd, 0xd8, 0xd2, 0x3f,
-       0xdf, 0xeb, 0x1e, 0xf8, 0x23, 0xae, 0xa3, 0xee,
-       0xbd, 0x20, 0xc1, 0x3b, 0x9b, 0x35, 0x9b, 0xd3,
-       0xef, 0xe0, 0xf6, 0x39, 0xd4, 0x52, 0x0b, 0x9f,
-       0xc6, 0x96, 0x3a, 0xc0, 0xdb, 0x49, 0x6b, 0x9f,
-       0x45, 0xd7, 0xe4, 0x97, 0xa8, 0x25, 0x4a, 0xf2,
-       0x64, 0x2a, 0x55, 0x42, 0x26, 0xeb, 0x75, 0x48,
-       0xff, 0x88, 0xe7, 0xbe, 0x28, 0x8c, 0xf9, 0xb6,
-       0x9e, 0x08, 0xb3, 0x7c, 0x71, 0x35, 0xf7, 0xce,
-       0x06, 0xcc, 0x17, 0xed, 0xfc, 0x5e, 0x9c, 0xd9,
-       0xfd, 0xbc, 0x14, 0xc3, 0x8f, 0x63, 0x38, 0x84,
-       0xf4, 0x71, 0xb1, 0x7c, 0x9d, 0x37, 0xe4, 0x3b,
-       0xfe, 0x26, 0xf9, 0xae, 0x57, 0xf3, 0xcd, 0xbf,
-       0x2e, 0xdf, 0x36, 0x96, 0x53, 0x2a, 0x4a, 0x14,
-       0xdc, 0x03, 0x9f, 0xf6, 0xa0, 0x74, 0x9c, 0xa9,
-       0x1d, 0x39, 0x81, 0x39, 0x4d, 0xc0, 0xb0, 0x45,
-       0x82, 0xb7, 0x77, 0xc6, 0x7a, 0xf3, 0xc1, 0xeb,
-       0x73, 0x5a, 0xb0, 0xeb, 0x26, 0x39, 0x8d, 0xe3,
-       0x39, 0x61, 0xdf, 0x7a, 0x3e, 0xbe, 0x6f, 0x3d,
-       0x70, 0x5a, 0xeb, 0x5b, 0x45, 0x63, 0xe3, 0xad,
-       0xbf, 0xee, 0x82, 0xc8, 0xfc, 0xcb, 0xd0, 0xd8,
-       0x5e, 0x77, 0x02, 0xf3, 0x5a, 0x4c, 0xe5, 0xaa,
-       0xeb, 0xc2, 0xfc, 0xbb, 0xb1, 0x5c, 0x6e, 0x4c,
-       0x85, 0xda, 0x38, 0xe2, 0xc1, 0xf0, 0xb7, 0x30,
-       0x8c, 0x5e, 0xe8, 0xed, 0xb1, 0x43, 0x5e, 0xe6,
-       0x86, 0x72, 0x8d, 0xbb, 0xb1, 0x5c, 0x75, 0x8f,
-       0xa9, 0xe5, 0xca, 0x53, 0xcb, 0xa5, 0x8e, 0xeb,
-       0x75, 0x38, 0xcf, 0x06, 0xe6, 0x65, 0xeb, 0x92,
-       0x49, 0xaa, 0x7b, 0xe0, 0x2a, 0xea, 0xa5, 0x08,
-       0xe7, 0x73, 0x6f, 0x1d, 0xc3, 0xdc, 0x6e, 0xc3,
-       0x30, 0xa6, 0xfe, 0xf9, 0x4b, 0x31, 0xdf, 0x12,
-       0xb9, 0x3e, 0xb7, 0xf9, 0x2f, 0xdf, 0x24, 0xb7,
-       0x34, 0x35, 0xb7, 0x7c, 0x35, 0xb7, 0xb8, 0x91,
-       0x7d, 0xe1, 0x80, 0xbc, 0x5a, 0x0c, 0xaa, 0xd6,
-       0xb9, 0x38, 0xde, 0x36, 0x97, 0xec, 0x25, 0x3d,
-       0x50, 0x2f, 0x58, 0xf8, 0x9e, 0xbc, 0x20, 0x93,
-       0x5b, 0x26, 0x8d, 0x06, 0xe6, 0x2c, 0x03, 0xd2,
-       0xf6, 0x0f, 0xf9, 0x94, 0xc2, 0xf7, 0x62, 0x3e,
-       0xc5, 0xc6, 0x7d, 0xca, 0x92, 0x70, 0xbc, 0x56,
-       0x17, 0x3e, 0x3d, 0x7c, 0xee, 0xb0, 0x70, 0x3d,
-       0x9f, 0x3b, 0x2c, 0xc4, 0x15, 0xff, 0xcf, 0x0b,
-       0x45, 0xf8, 0x65, 0x56, 0x55, 0x7b, 0x48, 0x90,
-       0xd4, 0x3b, 0xbe, 0x42, 0x07, 0xdd, 0x0a, 0x66,
-       0xf7, 0xbc, 0x26, 0x5a, 0x6e, 0xf6, 0xb4, 0x6f,
-       0xd8, 0x63, 0xbc, 0xeb, 0x9f, 0xf4, 0xc5, 0xc1,
-       0x78, 0x3e, 0x06, 0xa2, 0x7f, 0xfa, 0x61, 0xe1,
-       0x4d, 0x9e, 0x1e, 0x62, 0x3a, 0x96, 0xf4, 0x3f,
-       0xf6, 0x74, 0xf2, 0xcf, 0x7a, 0x7a, 0xc9, 0x8b,
-       0x3d, 0x4c, 0x2e, 0xae, 0x95, 0x76, 0x8b, 0x70,
-       0x9c, 0xee, 0xb6, 0xe0, 0xbc, 0xb2, 0x90, 0xed,
-       0x25, 0x9e, 0xf9, 0x90, 0xcf, 0xa6, 0x18, 0x3d,
-       0x36, 0x51, 0xef, 0xc7, 0xf9, 0xf7, 0xbf, 0x5e,
-       0x98, 0x3b, 0xbf, 0xb6, 0x86, 0xee, 0x5a, 0x90,
-       0xba, 0x68, 0xa7, 0x83, 0x04, 0x5f, 0x7b, 0x9f,
-       0xf3, 0x59, 0x6d, 0xb8, 0x0a, 0x19, 0xe2, 0xdc,
-       0xaf, 0xdd, 0x05, 0xae, 0xc7, 0x05, 0x61, 0x1b,
-       0xdd, 0x5b, 0x52, 0xb7, 0xfd, 0xe1, 0xf2, 0x8b,
-       0xbd, 0xd3, 0xe3, 0xed, 0x10, 0xd9, 0x9b, 0x20,
-       0xde, 0x0e, 0x09, 0xf2, 0x70, 0x76, 0x3d, 0x65,
-       0x0f, 0x5b, 0xf5, 0xe0, 0x78, 0x96, 0xb7, 0x14,
-       0xb1, 0x17, 0x19, 0xd6, 0xc8, 0x56, 0x86, 0x62,
-       0x3b, 0x4c, 0xd9, 0xaa, 0x3e, 0x5b, 0x11, 0xf9,
-       0x9a, 0x6d, 0xca, 0x06, 0xb3, 0x8e, 0xc1, 0x75,
-       0xda, 0xfa, 0x28, 0xaf, 0x00, 0xb1, 0xba, 0x7c,
-       0xda, 0x77, 0xe1, 0xa0, 0x91, 0xc1, 0xcd, 0xec,
-       0x52, 0x32, 0x62, 0x59, 0x0a, 0xd3, 0x29, 0x9f,
-       0xc6, 0x9d, 0x4c, 0x16, 0x7a, 0xb7, 0x15, 0x99,
-       0xec, 0x5d, 0x29, 0x6f, 0x87, 0x62, 0xf4, 0x87,
-       0x6b, 0x1e, 0xa5, 0xb5, 0x94, 0x77, 0x09, 0xce,
-       0x88, 0xdf, 0xa6, 0x95, 0x94, 0x2c, 0xa3, 0xdf,
-       0xfd, 0x87, 0x6b, 0x4b, 0x16, 0x7d, 0x9b, 0xad,
-       0x36, 0x45, 0xb6, 0xda, 0x6c, 0x74, 0x54, 0xb0,
-       0x15, 0x62, 0xfa, 0x97, 0x79, 0x9a, 0x92, 0x7a,
-       0x69, 0x77, 0x6d, 0x9b, 0xb5, 0xa7, 0x76, 0xb9,
-       0x59, 0x78, 0xf3, 0x95, 0xb7, 0x5a, 0x01, 0x8e,
-       0xd5, 0x3e, 0x1e, 0xeb, 0x45, 0x87, 0x7e, 0x70,
-       0x78, 0xf9, 0x4e, 0x11, 0x7b, 0xd3, 0x5f, 0x9c,
-       0xcb, 0x13, 0xbb, 0x37, 0xb7, 0x59, 0x7a, 0x36,
-       0x2f, 0x37, 0xb1, 0x5c, 0xda, 0x62, 0x79, 0x34,
-       0x62, 0x0e, 0xbb, 0xc5, 0x07, 0xff, 0x62, 0xf9,
-       0xd9, 0xbb, 0x53, 0x51, 0x7e, 0xaa, 0x2a, 0x3f,
-       0xd9, 0xaf, 0xc9, 0x37, 0x92, 0x7c, 0x61, 0x2f,
-       0x59, 0x0e, 0x7b, 0x27, 0x74, 0xdb, 0x6c, 0x5c,
-       0x69, 0xe4, 0x1f, 0x67, 0xeb, 0x5f, 0x6c, 0xbd,
-       0xfb, 0xf6, 0x30, 0xda, 0x7c, 0xa4, 0x1d, 0x10,
-       0x92, 0x58, 0x7e, 0x8c, 0x5a, 0xd5, 0x59, 0xd3,
-       0x20, 0xb5, 0x09, 0x41, 0x7a, 0xf8, 0xc6, 0xef,
-       0xb4, 0x4f, 0xc1, 0x8b, 0x04, 0xce, 0x2e, 0x19,
-       0xee, 0x7e, 0x2e, 0x07, 0x32, 0x13, 0x1d, 0x89,
-       0xb1, 0x56, 0x79, 0xb4, 0xe6, 0xb1, 0x12, 0x3e,
-       0x73, 0xa9, 0x08, 0x45, 0x79, 0xfb, 0x2c, 0xa5,
-       0xe7, 0xe2, 0xb8, 0xbe, 0xc9, 0x6f, 0x13, 0xe1,
-       0x5f, 0x1a, 0xb1, 0xb5, 0x0e, 0xb0, 0xd6, 0x7a,
-       0x30, 0x18, 0x9b, 0xfd, 0xe8, 0xac, 0xbb, 0x9e,
-       0xc2, 0xd6, 0x35, 0x39, 0x16, 0x7d, 0x99, 0xfa,
-       0x8d, 0xa9, 0xdc, 0x53, 0xdb, 0x76, 0x60, 0x77,
-       0xed, 0xf2, 0x88, 0x30, 0x39, 0x3a, 0x98, 0xc1,
-       0xdf, 0x32, 0x6a, 0xc1, 0x92, 0xae, 0x64, 0x21,
-       0x9c, 0x5f, 0xe6, 0x1b, 0xc5, 0xe7, 0x87, 0xa4,
-       0xc3, 0xcb, 0x24, 0x1d, 0x76, 0x7c, 0x39, 0xe9,
-       0x29, 0x17, 0xf7, 0x6c, 0x46, 0xe9, 0x9b, 0x6f,
-       0x90, 0x3e, 0x56, 0x93, 0x9e, 0xf7, 0x42, 0x9c,
-       0xf4, 0x6a, 0x94, 0x5d, 0xf9, 0x25, 0x25, 0x6f,
-       0xde, 0x93, 0xda, 0x76, 0x68, 0x77, 0xea, 0xf2,
-       0x03, 0xc3, 0x25, 0x4f, 0x8b, 0xc4, 0x24, 0x57,
-       0x8a, 0x3b, 0x32, 0xd6, 0xfd, 0x70, 0x10, 0xdb,
-       0xbf, 0xae, 0xd5, 0x2c, 0xf8, 0x04, 0xf4, 0x7f,
-       0x83, 0xd7, 0xae, 0x7f, 0x56, 0x97, 0x97, 0x29,
-       0xc2, 0xb1, 0x71, 0xfc, 0x56, 0x6f, 0x27, 0x2e,
-       0x7d, 0x6a, 0x6b, 0x62, 0x1b, 0x73, 0x27, 0xd2,
-       0x53, 0xce, 0x9f, 0xed, 0xa4, 0x77, 0x0a, 0xbc,
-       0x4f, 0x28, 0x41, 0xfe, 0x4c, 0x76, 0x52, 0x1f,
-       0x98, 0x11, 0x0f, 0x21, 0xb4, 0x22, 0x5c, 0x89,
-       0xd0, 0x86, 0xb0, 0x0b, 0x61, 0x2a, 0xc2, 0x30,
-       0x42, 0xea, 0x77, 0x8f, 0x21, 0xcc, 0x46, 0xd8,
-       0x5d, 0x32, 0x00, 0xa7, 0x27, 0x56, 0x80, 0x19,
-       0xe1, 0x59, 0x84, 0x56, 0x84, 0x7d, 0x08, 0x6d,
-       0x08, 0x2f, 0x20, 0x4c, 0x45, 0xd8, 0x8f, 0xd0,
-       0x81, 0xf0, 0x32, 0xc2, 0x6c, 0x2a, 0xd7, 0x9c,
-       0xcb, 0x12, 0xe4, 0x3e, 0x29, 0x76, 0xf1, 0x1c,
-       0x31, 0xe6, 0xd9, 0x1f, 0x60, 0xae, 0xb2, 0x99,
-       0x3d, 0x0f, 0x0e, 0x31, 0x59, 0x5b, 0x90, 0x62,
-       0x55, 0x29, 0x2b, 0x99, 0xd4, 0x4d, 0x48, 0xb1,
-       0xa9, 0x94, 0x2e, 0x26, 0xff, 0x09, 0xa4, 0xa4,
-       0xaa, 0x94, 0x30, 0xcb, 0x69, 0x3d, 0x52, 0x1c,
-       0x2a, 0xe5, 0x31, 0x96, 0x67, 0x18, 0x29, 0xd9,
-       0x2a, 0xa5, 0x9b, 0xe7, 0x5e, 0x85, 0xda, 0xcd,
-       0xc5, 0xf1, 0xef, 0x67, 0xc9, 0x22, 0xfc, 0x42,
-       0x5f, 0xda, 0x54, 0xdf, 0xa9, 0x68, 0x9b, 0xb3,
-       0xd0, 0x69, 0xc5, 0xe3, 0xb2, 0x4c, 0x5e, 0x6c,
-       0x0c, 0x7f, 0xb7, 0xb3, 0x41, 0x84, 0x1f, 0x3f,
-       0x8f, 0x61, 0xbd, 0x1a, 0xde, 0xc2, 0xde, 0x25,
-       0xe7, 0xe1, 0x27, 0xc6, 0x0c, 0xb2, 0xf7, 0xff,
-       0x29, 0x4c, 0xbb, 0x8d, 0x12, 0xd4, 0x70, 0x08,
-       0xc3, 0x26, 0x35, 0xdc, 0x4c, 0x6f, 0x71, 0xa8,
-       0xef, 0xdf, 0x36, 0x28, 0xb6, 0x0f, 0xbd, 0xc2,
-       0x37, 0x00, 0x67, 0xc1, 0xce, 0xf5, 0x6c, 0x36,
-       0xdb, 0x40, 0xef, 0x6c, 0xa8, 0xa7, 0x7b, 0x6d,
-       0xab, 0x7a, 0x16, 0x7f, 0x3f, 0xc4, 0xdf, 0x51,
-       0xfc, 0xfd, 0x0e, 0xb6, 0xcd, 0x1d, 0x8d, 0xbf,
-       0xdc, 0xa1, 0x92, 0x4d, 0x13, 0x3c, 0x9d, 0x1d,
-       0x42, 0x53, 0x30, 0xd8, 0x1e, 0x8c, 0x2f, 0xf0,
-       0x34, 0x41, 0x73, 0xc6, 0x12, 0xdf, 0xb6, 0x70,
-       0xf3, 0x48, 0x7a, 0x1a, 0x1a, 0xec, 0x6c, 0x08,
-       0xb5, 0xb4, 0xb7, 0x0d, 0x67, 0x28, 0x6d, 0x59,
-       0xd1, 0xd2, 0x81, 0x54, 0x3a, 0xfb, 0x67, 0x75,
-       0x53, 0xb0, 0x7d, 0x78, 0x6c, 0x65, 0x4b, 0x5b,
-       0xd3, 0x14, 0xf7, 0xe7, 0xa7, 0x66, 0xf1, 0xe5,
-       0xc3, 0xe3, 0x41, 0x7b, 0x97, 0xb8, 0xac, 0x02,
-       0xfb, 0xd4, 0x19, 0xbe, 0x3b, 0x5d, 0x82, 0x66,
-       0xbe, 0xbf, 0xdc, 0xa7, 0x58, 0xf8, 0x4e, 0x75,
-       0x5c, 0xdb, 0xb5, 0xd2, 0x49, 0x72, 0xbb, 0xe9,
-       0x3d, 0xe3, 0x6d, 0xff, 0xd4, 0xcc, 0xae, 0x3b,
-       0xc8, 0xce, 0xe5, 0xb6, 0x60, 0x54, 0xd8, 0x47,
-       0xff, 0xe8, 0x8c, 0x3a, 0xb9, 0x95, 0xbd, 0xd5,
-       0xe7, 0x45, 0x59, 0x4f, 0x0f, 0xdd, 0x6d, 0x4d,
-       0x7d, 0xa3, 0xc6, 0x85, 0x14, 0xf6, 0x14, 0x3b,
-       0xf5, 0x97, 0x18, 0x0e, 0xb1, 0xd0, 0x45, 0x0c,
-       0x2d, 0xa5, 0xd0, 0x2d, 0x26, 0x0c, 0x89, 0x2c,
-       0x34, 0x16, 0x43, 0x0b, 0xd8, 0x0e, 0xf8, 0x71,
-       0x18, 0xaa, 0x64, 0x21, 0x33, 0x86, 0x3c, 0x2c,
-       0xf6, 0x53, 0x0c, 0xb1, 0x37, 0x89, 0x6f, 0x39,
-       0x8d, 0xa1, 0x1c, 0x16, 0x3a, 0x8c, 0xa1, 0x0c,
-       0x16, 0xda, 0x83, 0x21, 0xd6, 0xab, 0x6f, 0x59,
-       0x89, 0x21, 0x1b, 0x0b, 0x35, 0x62, 0x88, 0x8d,
-       0x9f, 0xb7, 0xcc, 0x96, 0x20, 0x67, 0x2f, 0x7f,
-       0xe3, 0x57, 0x82, 0xbb, 0x37, 0xca, 0x90, 0xd9,
-       0x2b, 0xb8, 0x90, 0xb6, 0x43, 0x84, 0xde, 0x67,
-       0x91, 0xb2, 0x06, 0x29, 0xaf, 0x6b, 0x7b, 0x09,
-       0xee, 0x0e, 0x20, 0xd6, 0x73, 0xe3, 0x5e, 0x82,
-       0xcc, 0x67, 0xf8, 0x5e, 0x82, 0x20, 0x68, 0xa3,
-       0xdd, 0xdd, 0xe5, 0xcb, 0x20, 0x73, 0x69, 0x1b,
-       0x7b, 0x77, 0xa8, 0xc2, 0x51, 0xa8, 0xf7, 0xbb,
-       0xc7, 0x84, 0x05, 0x38, 0xdd, 0x3d, 0xef, 0x70,
-       0xf4, 0x8a, 0xbf, 0xe4, 0xe8, 0x1b, 0x3f, 0x18,
-       0x44, 0xfe, 0xbe, 0xe5, 0xbd, 0x35, 0x6e, 0xe4,
-       0xf3, 0x68, 0xbb, 0x0d, 0x7e, 0x70, 0x08, 0x65,
-       0x55, 0xf3, 0x1d, 0x06, 0x36, 0xbe, 0xc3, 0x60,
-       0x85, 0xea, 0x81, 0x5a, 0xe9, 0x79, 0xbb, 0x37,
-       0xfd, 0xcb, 0xed, 0x17, 0x48, 0xb6, 0xf9, 0xbb,
-       0x7b, 0xc6, 0xc9, 0xaf, 0x17, 0xe8, 0x32, 0x7d,
-       0xa2, 0x29, 0xed, 0xf6, 0xdd, 0xe3, 0xe4, 0x9d,
-       0x98, 0xf3, 0x55, 0xda, 0x93, 0x41, 0x77, 0x63,
-       0x6f, 0xb6, 0x6f, 0xa0, 0x10, 0x57, 0x3c, 0x53,
-       0x76, 0xd2, 0x8e, 0x0c, 0x71, 0xfd, 0xf5, 0xbe,
-       0x68, 0xca, 0x56, 0x11, 0xde, 0xd9, 0x48, 0x5e,
-       0x27, 0xab, 0x4d, 0x86, 0x3b, 0x5f, 0x8e, 0x74,
-       0x45, 0xaf, 0x69, 0x3a, 0xc9, 0x5a, 0x82, 0x94,
-       0x67, 0x62, 0x94, 0x61, 0x7a, 0xb9, 0xf3, 0x31,
-       0x6d, 0x8f, 0x45, 0xa6, 0x91, 0xd6, 0x8c, 0x77,
-       0xb2, 0x27, 0x7c, 0xde, 0x2d, 0x38, 0x17, 0xc9,
-       0x92, 0xcd, 0xf4, 0xce, 0xbe, 0x3c, 0x20, 0x5e,
-       0xb0, 0xd9, 0x68, 0xdf, 0xc5, 0x9d, 0xaf, 0xdb,
-       0xe2, 0xf6, 0x5d, 0x90, 0x26, 0xee, 0x2c, 0xcf,
-       0x49, 0xe2, 0x6b, 0xce, 0xec, 0x24, 0x2e, 0x27,
-       0x2b, 0x69, 0xa5, 0xe5, 0x95, 0x9f, 0xa1, 0x56,
-       0x36, 0xc4, 0xbc, 0x7e, 0x98, 0xeb, 0x65, 0xaa,
-       0x99, 0xf6, 0xd1, 0x8d, 0xb4, 0x0b, 0xe5, 0x01,
-       0xac, 0xff, 0x9a, 0x90, 0x50, 0x66, 0xb3, 0xa7,
-       0x97, 0xa7, 0xdc, 0xb6, 0xd3, 0xa8, 0xd4, 0xee,
-       0x04, 0xf9, 0x4a, 0x86, 0x37, 0xb3, 0x22, 0x75,
-       0xac, 0x92, 0x92, 0x72, 0x3b, 0x52, 0xfa, 0x76,
-       0x15, 0x43, 0x96, 0xd2, 0xbf, 0x53, 0xaf, 0x5c,
-       0x10, 0x4f, 0x3a, 0x16, 0x7e, 0x19, 0x8d, 0x5a,
-       0x5f, 0x47, 0xc9, 0xe8, 0xa7, 0xd7, 0x8c, 0x15,
-       0x70, 0x34, 0xcd, 0xde, 0x20, 0x3c, 0x54, 0xdb,
-       0x2d, 0x42, 0x34, 0x24, 0xc2, 0xdb, 0x2b, 0x25,
-       0x98, 0x5c, 0x27, 0x43, 0xc6, 0x16, 0x4d, 0x23,
-       0x93, 0x71, 0x5d, 0x9a, 0xb1, 0x61, 0xb8, 0x36,
-       0x34, 0x3d, 0x64, 0x0c, 0x92, 0x1e, 0x32, 0xba,
-       0xb9, 0x1e, 0x78, 0xcd, 0x33, 0x76, 0x5e, 0x5f,
-       0xf3, 0x8c, 0x4a, 0xb5, 0xe6, 0xe3, 0x6e, 0xa8,
-       0xf9, 0xc6, 0x58, 0xcd, 0xd7, 0x0f, 0xd5, 0xfc,
-       0xcb, 0xd4, 0x60, 0xc4, 0x20, 0x95, 0xfc, 0xd6,
-       0xbd, 0x71, 0x9a, 0x99, 0x16, 0xa7, 0x19, 0x2b,
-       0xd7, 0x0c, 0xea, 0xe4, 0x92, 0x78, 0x46, 0xb8,
-       0x95, 0x9f, 0x26, 0x31, 0x2b, 0x65, 0x34, 0xbd,
-       0x77, 0x9c, 0x64, 0x1b, 0xa4, 0x5d, 0xaa, 0xf9,
-       0xd7, 0xdc, 0xea, 0x1d, 0x80, 0xbb, 0xb1, 0xfe,
-       0x7e, 0xaa, 0x3f, 0x8e, 0xf5, 0x3f, 0xc7, 0xfa,
-       0x3b, 0xea, 0x96, 0xc1, 0xa4, 0x2e, 0xc5, 0x12,
-       0x00, 0xfe, 0xf6, 0xee, 0x42, 0x57, 0x50, 0xd7,
-       0xb3, 0xb6, 0x0d, 0x26, 0x35, 0xfb, 0xc2, 0x18,
-       0x53, 0xef, 0x66, 0x2b, 0x65, 0x9f, 0x13, 0x40,
-       0x81, 0x49, 0xb5, 0x0b, 0x5c, 0x74, 0x62, 0x22,
-       0x72, 0x01, 0xeb, 0xef, 0x2f, 0xa1, 0xbc, 0x69,
-       0xf4, 0xfc, 0x2f, 0xbf, 0x00, 0xa5, 0x65, 0x69,
-       0x3b, 0x49, 0x7e, 0x2e, 0x0c, 0xbd, 0x93, 0x3f,
-       0x73, 0x21, 0xe2, 0x36, 0xea, 0xa1, 0x77, 0x5d,
-       0x44, 0x79, 0x39, 0x32, 0x3b, 0xbf, 0x69, 0xc6,
-       0x15, 0x8d, 0xf7, 0xc8, 0x65, 0xed, 0xde, 0xc4,
-       0xa4, 0x67, 0x48, 0xbf, 0x93, 0x70, 0x7e, 0x7c,
-       0xd7, 0x01, 0x19, 0x26, 0x19, 0x29, 0xff, 0xf4,
-       0x6b, 0x74, 0xdf, 0x3b, 0xb2, 0x6e, 0x68, 0x65,
-       0xe4, 0xdd, 0x8c, 0x2b, 0xa3, 0x71, 0x19, 0xc6,
-       0xf4, 0x59, 0x99, 0x93, 0x71, 0x22, 0x65, 0x48,
-       0x37, 0x1c, 0x5d, 0x27, 0xe8, 0x69, 0x1d, 0xe2,
-       0xbb, 0xc2, 0xae, 0xcf, 0x20, 0xff, 0x0e, 0xf6,
-       0xc4, 0xd1, 0x2b, 0xb3, 0xb7, 0x79, 0xc6, 0x20,
-       0x25, 0x6b, 0x73, 0xd0, 0x2c, 0x98, 0x70, 0x64,
-       0x7e, 0x02, 0x73, 0x5c, 0x17, 0xcb, 0x31, 0x0b,
-       0x73, 0xb4, 0x68, 0x77, 0xc1, 0xe7, 0xed, 0xe4,
-       0x3a, 0xf2, 0xd8, 0xd2, 0xb1, 0x65, 0xfd, 0xc7,
-       0x30, 0x7f, 0x73, 0xa6, 0x9b, 0x9e, 0xc0, 0xf8,
-       0x71, 0xa6, 0x7b, 0xa4, 0x52, 0x4b, 0x95, 0x7e,
-       0xb9, 0x0b, 0xb4, 0x34, 0xfe, 0x97, 0xa9, 0x94,
-       0xb0, 0x75, 0x2a, 0x70, 0xce, 0x79, 0x27, 0x84,
-       0x09, 0xbe, 0x30, 0x9d, 0x87, 0xe0, 0x5f, 0x9f,
-       0xee, 0xe2, 0xcf, 0xa5, 0x6c, 0xb8, 0x5e, 0xca,
-       0xf0, 0x86, 0xc6, 0xa7, 0x46, 0xe8, 0xbd, 0x43,
-       0x4f, 0x4a, 0x19, 0x7f, 0x26, 0x35, 0x56, 0xd4,
-       0xdb, 0x4e, 0xb0, 0xe7, 0xd0, 0xea, 0x93, 0xb0,
-       0xc9, 0xfd, 0xbe, 0xc9, 0x30, 0x5d, 0xb1, 0x52,
-       0xcf, 0x9d, 0x1f, 0x40, 0xfc, 0xb4, 0x68, 0x11,
-       0xb0, 0x8e, 0x41, 0xac, 0x55, 0x6e, 0x3f, 0xa3,
-       0xae, 0x42, 0xea, 0x61, 0x41, 0x3d, 0xd3, 0xe4,
-       0x7e, 0xf7, 0x51, 0x77, 0x78, 0x9f, 0xd7, 0xe5,
-       0x73, 0xd1, 0xbb, 0xe7, 0xff, 0xbc, 0x5a, 0xb5,
-       0x2e, 0x6b, 0x3a, 0xed, 0x70, 0x4c, 0xf3, 0x85,
-       0xdb, 0x20, 0xda, 0x75, 0xe6, 0xc9, 0xc6, 0x98,
-       0x27, 0x98, 0xbc, 0x51, 0x84, 0xb7, 0xd6, 0x0b,
-       0x82, 0xe0, 0x28, 0xad, 0xf0, 0x4f, 0xe6, 0x6b,
-       0xb8, 0xcc, 0xc5, 0x32, 0x4c, 0xdc, 0x2a, 0xb8,
-       0xd2, 0xbd, 0x9e, 0xef, 0x81, 0x31, 0x00, 0x79,
-       0xc5, 0x10, 0xed, 0xdd, 0xd2, 0xa8, 0xf7, 0x87,
-       0xe9, 0xad, 0xeb, 0xf2, 0xf0, 0x24, 0x17, 0x60,
-       0xdd, 0xdf, 0xaa, 0xc6, 0x3a, 0xf8, 0x45, 0x3a,
-       0x7b, 0x63, 0x21, 0x9d, 0xba, 0xe1, 0xc5, 0xb9,
-       0x44, 0xa6, 0x80, 0x29, 0x45, 0xd6, 0x53, 0x2e,
-       0x20, 0x96, 0x82, 0x58, 0x21, 0xe9, 0x62, 0xa2,
-       0x93, 0x9e, 0xe8, 0x9b, 0x4e, 0xb5, 0xc1, 0xc4,
-       0x4c, 0xb2, 0x15, 0x6f, 0x3f, 0x3d, 0x7b, 0xb9,
-       0xf3, 0x12, 0xc6, 0xa7, 0xb1, 0x78, 0x1b, 0xa3,
-       0x5e, 0x3a, 0x1a, 0xde, 0x49, 0x7c, 0xa7, 0xdb,
-       0x40, 0xb8, 0xc6, 0xe6, 0xb7, 0x17, 0xd8, 0x5c,
-       0xf4, 0xd2, 0xfe, 0x41, 0x3d, 0x1c, 0x0d, 0x4b,
-       0xf0, 0xfa, 0x93, 0x52, 0x8e, 0x9c, 0xc1, 0x9e,
-       0x4d, 0x5d, 0x50, 0xcf, 0x8c, 0xe8, 0xb7, 0xde,
-       0x0b, 0x0b, 0x29, 0x77, 0x19, 0xdb, 0xa7, 0xa0,
-       0x51, 0x9a, 0x46, 0x6f, 0x56, 0x16, 0xac, 0x43,
-       0xde, 0x3d, 0x22, 0x1c, 0x7e, 0x09, 0xc7, 0x7a,
-       0x1b, 0xbb, 0xaf, 0x23, 0xf2, 0xb3, 0x80, 0x7c,
-       0x4e, 0xc5, 0xc4, 0xf0, 0xdd, 0xb4, 0xd3, 0x79,
-       0xfa, 0x65, 0x6e, 0x13, 0x95, 0xa7, 0xcc, 0xfc,
-       0x8c, 0x1c, 0xe7, 0x75, 0xbc, 0x36, 0x7e, 0x9e,
-       0x90, 0xcf, 0x29, 0x8f, 0xe5, 0xa9, 0x32, 0x96,
-       0x81, 0xd5, 0xf3, 0x7d, 0x48, 0x09, 0xe8, 0xaa,
-       0x5e, 0x04, 0x1b, 0x1f, 0x2b, 0x2b, 0x4f, 0x59,
-       0x31, 0x75, 0x17, 0xcc, 0xa0, 0x7d, 0x29, 0x6c,
-       0x14, 0xfa, 0x1f, 0x4b, 0x68, 0x3f, 0xa6, 0x6a,
-       0x6f, 0x76, 0xb5, 0x0d, 0x6c, 0x27, 0xbb, 0x60,
-       0xc4, 0xbc, 0x77, 0xa2, 0xef, 0xe3, 0x3a, 0xce,
-       0x8a, 0x7d, 0x2c, 0x4d, 0x7a, 0x12, 0x4b, 0x68,
-       0x51, 0x9f, 0xd7, 0xb3, 0x5b, 0xe0, 0x2d, 0x1d,
-       0xc2, 0xdc, 0xd9, 0x38, 0xd5, 0x29, 0x6f, 0x0f,
-       0x2e, 0x97, 0xd4, 0xdb, 0xe2, 0x2d, 0x6d, 0x42,
-       0x23, 0x7b, 0x4c, 0x0b, 0x7c, 0x2b, 0x94, 0x30,
-       0x73, 0xe8, 0xfe, 0xb6, 0xb0, 0x86, 0xda, 0x71,
-       0x21, 0xd6, 0xe4, 0xae, 0x43, 0x43, 0x3d, 0x55,
-       0x82, 0xa9, 0xef, 0x31, 0x7a, 0x1a, 0xd2, 0x7b,
-       0x24, 0x9c, 0xfd, 0xb8, 0x07, 0xfa, 0x5e, 0xc5,
-       0xf0, 0xf3, 0x6c, 0x57, 0xd8, 0x0a, 0x09, 0xae,
-       0x9d, 0x97, 0x03, 0x74, 0x52, 0x14, 0xdf, 0x19,
-       0xb6, 0x26, 0x8a, 0x7d, 0x35, 0xa8, 0x3d, 0x47,
-       0xa0, 0xf2, 0xe7, 0xf5, 0x94, 0xb0, 0x27, 0xe3,
-       0x81, 0x09, 0x74, 0x4a, 0x91, 0x7a, 0x52, 0xd1,
-       0x15, 0x9e, 0x2b, 0xf6, 0x0e, 0xb4, 0x26, 0xda,
-       0xf5, 0xfc, 0x03, 0xb4, 0xcf, 0x5a, 0x8f, 0xf6,
-       0xfc, 0x7e, 0x61, 0x95, 0xb3, 0xd8, 0x80, 0x16,
-       0x9a, 0x4b, 0x65, 0xda, 0x5e, 0xd0, 0x83, 0xd8,
-       0xd7, 0x11, 0x23, 0xca, 0xdb, 0x98, 0xe3, 0xf3,
-       0x22, 0xbc, 0x39, 0x5e, 0x2b, 0xf7, 0x84, 0x83,
-       0xb1, 0x72, 0xdb, 0x86, 0x95, 0x7b, 0xbc, 0x56,
-       0xee, 0xcc, 0xab, 0x12, 0xbc, 0xb6, 0x17, 0xcb,
-       0x8d, 0xd4, 0xcc, 0x0b, 0xac, 0xdc, 0xab, 0x51,
-       0x4a, 0x9e, 0x1c, 0xfa, 0xf3, 0xca, 0x57, 0xb3,
-       0x5d, 0x2b, 0xdf, 0x82, 0x97, 0x79, 0xf9, 0x9c,
-       0xef, 0xc7, 0x97, 0xcf, 0xd9, 0xcb, 0xe3, 0xd3,
-       0xbd, 0x81, 0x47, 0x3c, 0x7f, 0x47, 0x3d, 0x4f,
-       0xd8, 0x5b, 0x3a, 0xb7, 0x46, 0x47, 0xd6, 0xe1,
-       0xdc, 0x85, 0x65, 0xc7, 0xd2, 0x7e, 0xd6, 0x27,
-       0xc2, 0xa1, 0x7a, 0xf4, 0x0c, 0x1e, 0x19, 0xc6,
-       0xbf, 0xa4, 0xee, 0x26, 0xa3, 0xfd, 0x32, 0x68,
-       0x71, 0x39, 0xaf, 0x55, 0x77, 0x77, 0x09, 0xb6,
-       0x83, 0x41, 0x0b, 0x86, 0xdf, 0xb3, 0x1d, 0x44,
-       0x7a, 0x7a, 0x90, 0xb5, 0xcf, 0x68, 0xf8, 0x60,
-       0x4b, 0x0a, 0xd8, 0x3e, 0xb1, 0x7d, 0x2e, 0x24,
-       0x5e, 0x96, 0xe2, 0xce, 0x90, 0x21, 0x98, 0xf8,
-       0x6e, 0xb8, 0xd1, 0x84, 0xe1, 0x5c, 0x91, 0x9e,
-       0x52, 0x3b, 0xb1, 0xa7, 0xf5, 0x23, 0xcc, 0x41,
-       0xef, 0xf0, 0x51, 0x4d, 0x37, 0x86, 0x2c, 0x1e,
-       0xbb, 0xe6, 0xad, 0xef, 0x3c, 0x29, 0xc2, 0xcf,
-       0x8e, 0x7a, 0x3f, 0x3e, 0x1d, 0x7f, 0x5e, 0x44,
-       0xd1, 0xd0, 0x79, 0x11, 0xda, 0x49, 0x0f, 0xfc,
-       0xdc, 0x88, 0x1f, 0x0f, 0x06, 0x13, 0x53, 0x73,
-       0xc0, 0xb4, 0xeb, 0x86, 0x13, 0x1f, 0xa8, 0xd7,
-       0xfa, 0xd0, 0x7a, 0x21, 0xb1, 0xaa, 0xd3, 0x66,
-       0x47, 0xff, 0xf4, 0x02, 0x7b, 0xef, 0xe2, 0x72,
-       0x4d, 0x37, 0x79, 0xc1, 0x69, 0xb0, 0x0c, 0xee,
-       0x58, 0x4f, 0xf4, 0x3b, 0x82, 0x43, 0xf4, 0xf4,
-       0x19, 0x32, 0xdc, 0x51, 0xff, 0x1a, 0xce, 0xfb,
-       0x97, 0x2f, 0x95, 0xcd, 0xdc, 0x6b, 0x8b, 0xad,
-       0x88, 0x8f, 0x51, 0x7d, 0xf8, 0x35, 0x0c, 0xa7,
-       0xaa, 0xe1, 0x01, 0x0c, 0x8f, 0x96, 0xcd, 0xd4,
-       0xb7, 0x67, 0x5c, 0x16, 0xcb, 0x11, 0x4b, 0xe1,
-       0x69, 0x66, 0xea, 0xc5, 0x22, 0xc4, 0x6e, 0x51,
-       0x31, 0x93, 0x98, 0x85, 0x58, 0x9a, 0x8a, 0xa5,
-       0x88, 0xe3, 0x10, 0xbb, 0x55, 0xc5, 0x2c, 0x62,
-       0xb2, 0x48, 0xde, 0x6f, 0xfb, 0x8c, 0x5d, 0x1f,
-       0xce, 0x99, 0x18, 0xae, 0x06, 0xba, 0xc3, 0x70,
-       0xf0, 0x18, 0xce, 0x7c, 0x0e, 0x05, 0xcd, 0x25,
-       0x8c, 0x2e, 0xdc, 0x46, 0xf1, 0x65, 0x35, 0x38,
-       0xaf, 0xc9, 0x56, 0xc3, 0xd8, 0xff, 0xa6, 0x08,
-       0x6a, 0xb8, 0x09, 0xc3, 0xa9, 0x6a, 0xb8, 0x0d,
-       0xc3, 0x66, 0x35, 0xfc, 0x30, 0x8e, 0xfb, 0x83,
-       0x6a, 0x18, 0x7d, 0x4b, 0x76, 0xbf, 0x1a, 0x7e,
-       0x1c, 0xc3, 0x67, 0xd5, 0xf0, 0x26, 0x0c, 0x1f,
-       0x57, 0xc3, 0x38, 0x7b, 0xcc, 0x3e, 0xa2, 0x86,
-       0xff, 0x11, 0xc3, 0x11, 0x35, 0x8c, 0x3d, 0x2c,
-       0x5b, 0x2b, 0x03, 0xf6, 0xb2, 0xec, 0x1d, 0x6a,
-       0x78, 0x3f, 0x86, 0x9f, 0x51, 0xc3, 0x6f, 0x61,
-       0x78, 0xa3, 0x1a, 0x3e, 0x86, 0xe1, 0xc7, 0xd4,
-       0xf0, 0xbf, 0x63, 0x78, 0x25, 0x3b, 0xc7, 0xef,
-       0x0a, 0xc3, 0xcf, 0x21, 0xde, 0xcc, 0xcf, 0xf5,
-       0x63, 0xf8, 0x1f, 0x10, 0xaf, 0x63, 0x38, 0x1b,
-       0xab, 0xcb, 0xd1, 0xb7, 0x65, 0x7b, 0xd9, 0x6e,
-       0x41, 0xbe, 0x13, 0x6a, 0x34, 0xe2, 0x45, 0xfc,
-       0x5c, 0x39, 0x86, 0x57, 0x21, 0xee, 0x60, 0xb8,
-       0x85, 0xe1, 0xa8, 0x87, 0x6c, 0x76, 0x6a, 0xdc,
-       0x4c, 0x36, 0xea, 0x95, 0xe3, 0x4c, 0x38, 0x9b,
-       0x3d, 0x39, 0x9f, 0x99, 0xcc, 0xf0, 0x7c, 0x1c,
-       0xab, 0xaf, 0xb2, 0xd0, 0x1d, 0x41, 0x23, 0x3f,
-       0xd3, 0x0f, 0x29, 0x1f, 0xc5, 0x9d, 0xeb, 0x97,
-       0x51, 0xcb, 0xf7, 0xca, 0x3a, 0x95, 0xb1, 0x75,
-       0xdd, 0x34, 0x27, 0x33, 0x3c, 0xe6, 0x4c, 0xa5,
-       0x73, 0xfe, 0x7a, 0x5d, 0xb4, 0x7b, 0xe6, 0xfe,
-       0xc1, 0xde, 0xcb, 0x00, 0xfc, 0xec, 0x21, 0x8c,
-       0x6b, 0xc6, 0x75, 0x56, 0x0d, 0x4a, 0xcb, 0xb0,
-       0xd6, 0x56, 0x75, 0xc8, 0x96, 0xda, 0x6e, 0xc4,
-       0xcb, 0x08, 0x67, 0x29, 0x7d, 0x42, 0x2a, 0xcb,
-       0x2b, 0x93, 0x7a, 0xce, 0xdd, 0x6c, 0xd6, 0x5a,
-       0x56, 0x4d, 0x4f, 0xf6, 0x69, 0x97, 0xe1, 0x88,
-       0xaa, 0xca, 0x53, 0x63, 0x0c, 0xb8, 0xf2, 0xd2,
-       0xe3, 0x3f, 0x13, 0xbb, 0xf2, 0x7f, 0x69, 0x90,
-       0x0c, 0x76, 0x5c, 0xeb, 0x32, 0xcc, 0xfb, 0xf1,
-       0x23, 0x57, 0xd9, 0xce, 0xe8, 0x56, 0x09, 0xf4,
-       0x03, 0xda, 0xe9, 0x45, 0x12, 0x84, 0xfc, 0xda,
-       0x88, 0x99, 0xfe, 0x7a, 0xe5, 0xa9, 0x09, 0xd7,
-       0xaa, 0x3a, 0x83, 0xc0, 0x6c, 0xfa, 0xc9, 0x21,
-       0xdb, 0x9d, 0xb0, 0x4e, 0x86, 0xb1, 0xfb, 0x99,
-       0x55, 0x35, 0x67, 0xba, 0x30, 0x36, 0x80, 0x71,
-       0x77, 0x29, 0x5e, 0xc6, 0xd1, 0x5f, 0xd3, 0xcd,
-       0xde, 0x21, 0x4a, 0xe1, 0x27, 0x08, 0xd1, 0x9c,
-       0x7f, 0x82, 0x9f, 0xaf, 0x8b, 0x2a, 0x52, 0x44,
-       0x18, 0xdb, 0xc6, 0x43, 0x0e, 0x5c, 0x5f, 0xe8,
-       0xd7, 0xf1, 0x55, 0xc0, 0x6d, 0x6c, 0x05, 0xe0,
-       0xff, 0x36, 0xad, 0x01, 0xaa, 0xf7, 0x89, 0x2f,
-       0xfb, 0x74, 0xf2, 0xf8, 0x4c, 0x2a, 0x5b, 0x33,
-       0xca, 0x4e, 0x65, 0xb2, 0x93, 0x19, 0xbf, 0xdf,
-       0x1e, 0xae, 0xde, 0xe7, 0xff, 0xb6, 0xd8, 0x87,
-       0x1c, 0x70, 0xc0, 0xce, 0xca, 0xdf, 0x2c, 0x58,
-       0x57, 0x24, 0xae, 0x1e, 0x25, 0x01, 0xec, 0xac,
-       0xb8, 0x00, 0x6c, 0x15, 0x53, 0x8e, 0xd6, 0x99,
-       0xce, 0x4f, 0x15, 0xfa, 0xce, 0x82, 0xb7, 0xa2,
-       0x1f, 0x4d, 0x3a, 0x42, 0x7c, 0x22, 0xbc, 0xf1,
-       0x11, 0xdf, 0x35, 0xe7, 0xd4, 0xf3, 0xdd, 0x72,
-       0xd6, 0xea, 0x66, 0x41, 0xce, 0xa2, 0xbd, 0x72,
-       0xe3, 0x7b, 0xd2, 0xf5, 0xe7, 0x1e, 0xdf, 0xb8,
-       0xd6, 0xe1, 0xaa, 0xf1, 0x48, 0xcd, 0xf1, 0x72,
-       0x26, 0xee, 0xc1, 0x52, 0x5d, 0xf4, 0x0c, 0xdb,
-       0x75, 0xc7, 0xf7, 0xdc, 0xd5, 0xb8, 0x36, 0x7a,
-       0xe2, 0xe4, 0x38, 0x99, 0x9c, 0xe6, 0x5e, 0x1c,
-       0x77, 0xc1, 0xe6, 0x70, 0xfd, 0x2d, 0x9d, 0xec,
-       0xe1, 0x91, 0xc6, 0xc5, 0xe4, 0x04, 0x48, 0x2a,
-       0xc9, 0xe2, 0xa5, 0x09, 0x00, 0x7f, 0x57, 0x7b,
-       0xf5, 0x28, 0x7a, 0x6b, 0x40, 0xb7, 0x92, 0x7b,
-       0x3a, 0x1a, 0x1b, 0x53, 0x36, 0xb0, 0x34, 0x5f,
-       0xa7, 0xb6, 0x9d, 0xfc, 0x3c, 0x0b, 0x7f, 0x83,
-       0x56, 0x3e, 0xe5, 0xdf, 0x0f, 0x62, 0x19, 0xba,
-       0x12, 0x43, 0x3a, 0xdb, 0xb8, 0xd4, 0x4f, 0x00,
-       0x8a, 0xe0, 0x50, 0x59, 0x9f, 0xd7, 0xf6, 0x3b,
-       0xcc, 0xee, 0x77, 0x2e, 0x40, 0xc9, 0xe7, 0x6b,
-       0xbb, 0xe7, 0xbd, 0x1d, 0x3d, 0xc3, 0xf7, 0x13,
-       0xa2, 0xe6, 0xd2, 0xf8, 0x5b, 0xdd, 0xd4, 0x62,
-       0x77, 0xf4, 0xca, 0x70, 0x9b, 0x8d, 0xb5, 0x58,
-       0x80, 0x69, 0x2d, 0x40, 0x5a, 0x0b, 0xa0, 0xaf,
-       0x85, 0xdd, 0x5a, 0x7b, 0x0b, 0x6f, 0x63, 0x09,
-       0x5d, 0x31, 0xad, 0x9d, 0x65, 0xe5, 0x0c, 0x88,
-       0xb0, 0xbf, 0xe7, 0x7a, 0xad, 0xb5, 0x09, 0x72,
-       0x36, 0xd5, 0xf6, 0x8e, 0xd5, 0xe9, 0xfa, 0xdf,
-       0xa8, 0x5a, 0x43, 0x59, 0x4b, 0x63, 0x92, 0x1e,
-       0x23, 0x49, 0x58, 0xa2, 0x0b, 0x7f, 0x4a, 0x6f,
-       0x28, 0x29, 0x8f, 0x49, 0x72, 0x32, 0xbd, 0xb9,
-       0x34, 0xbd, 0xa1, 0xb4, 0x71, 0x31, 0x69, 0x85,
-       0x9a, 0x34, 0x5e, 0x22, 0x4d, 0x73, 0xe3, 0xd5,
-       0xd1, 0x01, 0xf5, 0x57, 0xa4, 0xce, 0x05, 0x07,
-       0xa1, 0x8d, 0x66, 0xe4, 0xda, 0x98, 0xe2, 0x90,
-       0xdd, 0x7d, 0x60, 0x26, 0x4a, 0x00, 0x42, 0x33,
-       0x6d, 0xe3, 0x6c, 0xa8, 0x35, 0x5a, 0xed, 0xd9,
-       0x7e, 0xe6, 0xb1, 0x73, 0x2d, 0xa9, 0xeb, 0x83,
-       0x82, 0xb8, 0xf5, 0xc1, 0x62, 0xf5, 0xdc, 0x28,
-       0xeb, 0xa4, 0x41, 0x8d, 0x26, 0xe2, 0xfa, 0xe0,
-       0x87, 0x4b, 0x86, 0x70, 0xc4, 0x9e, 0x17, 0xf3,
-       0xe2, 0x56, 0x11, 0x99, 0x71, 0x69, 0x54, 0x9a,
-       0x88, 0xe3, 0xcb, 0x0f, 0x1d, 0x43, 0x38, 0x62,
-       0x01, 0xd6, 0x2a, 0xcd, 0xbc, 0x55, 0x70, 0xc5,
-       0x71, 0x8c, 0x9d, 0x5a, 0x91, 0x43, 0xbd, 0xeb,
-       0xd6, 0xd0, 0x50, 0xef, 0x1a, 0x97, 0x21, 0xc3,
-       0xad, 0x8d, 0xfc, 0x6e, 0xf1, 0xad, 0x4b, 0xd8,
-       0x1c, 0x70, 0x50, 0x9b, 0xcf, 0xef, 0xcb, 0x60,
-       0x1c, 0x7a, 0x8c, 0xc9, 0xa4, 0x99, 0xf0, 0xad,
-       0x02, 0xce, 0x07, 0x75, 0x00, 0xad, 0x70, 0x6b,
-       0x1a, 0x3b, 0x6d, 0xbd, 0x56, 0xe3, 0x8c, 0x0c,
-       0x04, 0x74, 0xe2, 0x05, 0x7e, 0x6e, 0xc3, 0xcc,
-       0xda, 0x9a, 0x6a, 0xc5, 0x2c, 0x3c, 0xc4, 0xdf,
-       0x3f, 0x18, 0xfe, 0xa6, 0x82, 0xf0, 0x10, 0xbd,
-       0xa7, 0x20, 0xc2, 0xf7, 0x70, 0x96, 0xcd, 0x66,
-       0x8a, 0x83, 0x3d, 0xff, 0x84, 0xe3, 0x9b, 0x59,
-       0x98, 0xa0, 0x72, 0x4f, 0x50, 0x4f, 0x53, 0x8b,
-       0xa5, 0x60, 0x2b, 0xb4, 0x41, 0x7e, 0x1f, 0x35,
-       0x96, 0x7a, 0x09, 0xed, 0x0a, 0xbf, 0x95, 0x9d,
-       0x59, 0x57, 0x61, 0x65, 0xe7, 0xef, 0x98, 0x99,
-       0x17, 0xb0, 0xd2, 0x1b, 0x43, 0x0a, 0xa4, 0x6d,
-       0x1e, 0xaa, 0xdf, 0xed, 0xa5, 0x32, 0xa4, 0x3d,
-       0x46, 0xf5, 0xaa, 0x60, 0x9e, 0x25, 0x6d, 0x65,
-       0x5c, 0x9c, 0x03, 0xe3, 0x9a, 0x59, 0x9c, 0x91,
-       0xc5, 0x2d, 0x89, 0x8b, 0xb3, 0x62, 0x5c, 0x25,
-       0x8b, 0x33, 0xf3, 0xd5, 0x63, 0x05, 0x6c, 0x0a,
-       0xb3, 0x33, 0xfe, 0xcc, 0x47, 0xc3, 0x1a, 0x85,
-       0x56, 0xd7, 0x69, 0x99, 0x82, 0x2b, 0xc3, 0x4d,
-       0xf7, 0x8f, 0x2b, 0xd0, 0x0a, 0x7e, 0xb0, 0x9d,
-       0xef, 0xc4, 0x62, 0xa7, 0x86, 0x58, 0x15, 0xab,
-       0xcd, 0x66, 0x7b, 0x37, 0x25, 0xf2, 0xca, 0xe1,
-       0xe5, 0x57, 0x44, 0x53, 0xca, 0x71, 0x84, 0x03,
-       0xc8, 0x73, 0x4c, 0x84, 0x9f, 0x1c, 0xa2, 0x1c,
-       0x6f, 0x39, 0x2f, 0x41, 0xda, 0xb4, 0x35, 0x80,
-       0xf9, 0xfa, 0x64, 0xe3, 0x9a, 0xa8, 0x98, 0xc7,
-       0xcf, 0x00, 0xa2, 0x5a, 0x57, 0xb8, 0x02, 0x51,
-       0xdf, 0xc6, 0x65, 0x36, 0xcf, 0xc6, 0x5c, 0x9c,
-       0xb9, 0x4f, 0x74, 0x81, 0x09, 0xed, 0xcb, 0x22,
-       0x5e, 0x60, 0xab, 0x35, 0x5c, 0x83, 0xdd, 0x81,
-       0xeb, 0x9f, 0x9f, 0xac, 0xab, 0x61, 0x35, 0xd6,
-       0x1f, 0x1d, 0x2a, 0xf9, 0x58, 0xbf, 0x0c, 0xb7,
-       0x6c, 0xe2, 0x2d, 0x7a, 0xcb, 0x86, 0x0c, 0x76,
-       0x7e, 0x64, 0x85, 0xcb, 0xf7, 0xd4, 0x32, 0xfb,
-       0x0f, 0xdf, 0x55, 0x4c, 0x25, 0xe7, 0x50, 0xc6,
-       0x25, 0x6b, 0x4b, 0x34, 0x0a, 0x46, 0x39, 0xc0,
-       0xb0, 0xb3, 0x31, 0x0e, 0x4c, 0xe7, 0x7b, 0x4a,
-       0x36, 0xf3, 0x58, 0x95, 0xb7, 0xcf, 0xf7, 0x2d,
-       0x25, 0x33, 0x7d, 0x83, 0xc3, 0x87, 0x33, 0x2a,
-       0x57, 0x7e, 0x2d, 0x18, 0x27, 0xb5, 0x92, 0xa7,
-       0xc7, 0x35, 0x18, 0x1b, 0xab, 0x52, 0x47, 0x62,
-       0x49, 0x70, 0xb5, 0x94, 0x71, 0x4d, 0x1c, 0xaf,
-       0x72, 0x8d, 0x25, 0x2e, 0x2d, 0x7e, 0x4c, 0x3f,
-       0x5a, 0xd0, 0x19, 0x8c, 0x7f, 0x5f, 0x84, 0xd7,
-       0x8f, 0x15, 0xe0, 0xca, 0xc4, 0xf3, 0x14, 0xae,
-       0x84, 0x4c, 0x3d, 0xac, 0x45, 0x15, 0xe3, 0x9d,
-       0x2e, 0xd0, 0x4f, 0xea, 0x62, 0xcf, 0x57, 0x4c,
-       0xf9, 0x5d, 0x94, 0x6f, 0x4c, 0x72, 0x0e, 0xa6,
-       0xdc, 0x81, 0x29, 0x71, 0x0e, 0xfa, 0xfa, 0x56,
-       0x9c, 0x37, 0x9d, 0x66, 0x77, 0xfa, 0x16, 0xb1,
-       0xeb, 0x62, 0x76, 0xbd, 0x9f, 0x5d, 0x97, 0x70,
-       0x6d, 0xa1, 0xae, 0x16, 0xc8, 0xc9, 0xd6, 0x66,
-       0x56, 0x33, 0x55, 0x57, 0xd6, 0x1d, 0x5c, 0xb2,
-       0x92, 0x92, 0x5e, 0x9d, 0xb7, 0xb7, 0xea, 0x55,
-       0x9a, 0x5f, 0x36, 0x6c, 0x9c, 0xe4, 0x03, 0xbd,
-       0x98, 0x91, 0x5e, 0xfd, 0x03, 0x76, 0xfa, 0xa2,
-       0xcc, 0xde, 0x42, 0x9d, 0xb9, 0x44, 0x3b, 0x83,
-       0x4e, 0xb4, 0xe4, 0xed, 0xf5, 0xf1, 0x3e, 0xb0,
-       0x88, 0x49, 0x79, 0x81, 0xf5, 0xb7, 0x45, 0x8a,
-       0x3d, 0x76, 0x87, 0xd7, 0x46, 0xa7, 0x47, 0x32,
-       0x59, 0x45, 0x13, 0x7d, 0x60, 0xab, 0x3c, 0x95,
-       0x98, 0xc8, 0x4f, 0xba, 0x8c, 0x95, 0x24, 0x13,
-       0xb5, 0xc8, 0x4a, 0xa2, 0xa4, 0x61, 0xce, 0x3b,
-       0xc0, 0x18, 0x2b, 0x89, 0x69, 0x52, 0x33, 0x8d,
-       0x93, 0x4c, 0xf2, 0x7b, 0xb1, 0x33, 0x32, 0x0f,
-       0x08, 0xed, 0x90, 0xcc, 0x6b, 0x16, 0x6b, 0x8d,
-       0x82, 0x58, 0x4b, 0x18, 0x5f, 0xd1, 0x5a, 0xae,
-       0xcf, 0xc9, 0x34, 0xc8, 0x35, 0x45, 0x77, 0x1e,
-       0x2a, 0x0a, 0x58, 0x49, 0x17, 0x57, 0x9e, 0x9a,
-       0x04, 0x22, 0xbc, 0xe0, 0x21, 0x38, 0x95, 0x9d,
-       0x6e, 0xc9, 0xe4, 0x0a, 0xe4, 0xcb, 0x2b, 0x8a,
-       0xbc, 0x47, 0x0d, 0x50, 0x79, 0xca, 0x88, 0x3f,
-       0x1d, 0xf3, 0x63, 0x15, 0x05, 0xe9, 0xdd, 0xe9,
-       0xbc, 0x36, 0xe7, 0x20, 0x8c, 0xf5, 0x38, 0x48,
-       0xab, 0x9b, 0x49, 0x5e, 0x08, 0x57, 0xb1, 0x37,
-       0xd2, 0x27, 0xad, 0x22, 0x1a, 0xb0, 0xfd, 0x84,
-       0x15, 0x05, 0x0f, 0x74, 0xb3, 0xb3, 0x7c, 0xee,
-       0xf7, 0x8c, 0x8e, 0x95, 0xad, 0xea, 0xf3, 0xca,
-       0x36, 0xb1, 0x85, 0x6a, 0x17, 0x2b, 0xa1, 0xda,
-       0xb2, 0x71, 0x25, 0xbd, 0x9f, 0xdf, 0x61, 0xa9,
-       0x28, 0x9a, 0xca, 0x64, 0xd3, 0x29, 0xc2, 0xff,
-       0xeb, 0x09, 0x2d, 0xac, 0xc5, 0x55, 0x75, 0xf0,
-       0x9c, 0x82, 0x66, 0xcc, 0xcb, 0x19, 0xcb, 0x4b,
-       0xf0, 0x7d, 0x0f, 0x4c, 0xcb, 0x2c, 0xc2, 0x68,
-       0x66, 0x1f, 0xa2, 0x68, 0x56, 0x43, 0x73, 0xd1,
-       0xea, 0xd7, 0xe0, 0x28, 0xbc, 0x9a, 0x95, 0xe3,
-       0x88, 0x08, 0x7b, 0x97, 0x62, 0xaf, 0xa8, 0xd7,
-       0x46, 0xa4, 0x49, 0xec, 0x8d, 0x5a, 0xf4, 0x23,
-       0x38, 0x8f, 0xba, 0xb5, 0x40, 0x86, 0x94, 0xba,
-       0x9e, 0x2e, 0x30, 0xd4, 0x43, 0x4a, 0x35, 0x5b,
-       0xbf, 0xd2, 0x89, 0x9a, 0x7a, 0x19, 0x3d, 0xe8,
-       0xad, 0x76, 0x8c, 0x2b, 0x66, 0x3e, 0xb0, 0x14,
-       0x65, 0x64, 0x22, 0xc5, 0x84, 0x94, 0x72, 0xde,
-       0x97, 0x52, 0x66, 0xb0, 0x11, 0x0d, 0x67, 0x30,
-       0x69, 0xfd, 0x7c, 0xa6, 0xec, 0x75, 0xb1, 0x39,
-       0x59, 0x2b, 0xdd, 0x75, 0x73, 0xb8, 0x68, 0xbc,
-       0x61, 0xb2, 0x74, 0x72, 0xf2, 0xd4, 0x54, 0x21,
-       0x3b, 0x3a, 0x58, 0x1e, 0xf6, 0xba, 0x5e, 0xd9,
-       0x2c, 0x66, 0x52, 0x6e, 0xb2, 0x30, 0x35, 0x75,
-       0x6a, 0x36, 0x18, 0x89, 0xde, 0x4b, 0x4f, 0xd8,
-       0x4a, 0x5f, 0xd9, 0xfc, 0xca, 0x4b, 0x68, 0x17,
-       0xb5, 0xef, 0xcc, 0x92, 0x8d, 0x45, 0x7b, 0xab,
-       0x36, 0xd1, 0xc9, 0x8e, 0x9f, 0xbe, 0xaf, 0xce,
-       0x8d, 0xb0, 0x57, 0x2d, 0x2b, 0x74, 0x3c, 0x94,
-       0x43, 0x32, 0x5d, 0x4a, 0x1a, 0x9d, 0x1f, 0x58,
-       0xe3, 0x72, 0x1f, 0x2b, 0xb9, 0xbc, 0x12, 0x52,
-       0x62, 0xe7, 0x06, 0xae, 0x01, 0x6b, 0xad, 0x6f,
-       0x50, 0x36, 0x9a, 0x7f, 0x06, 0xb6, 0x19, 0x2c,
-       0xf7, 0xd7, 0x29, 0x77, 0xa3, 0xe3, 0x7f, 0x8a,
-       0xd6, 0xd7, 0x29, 0x4f, 0xd3, 0xe4, 0x87, 0x00,
-       0xb1, 0xe3, 0x11, 0x73, 0x22, 0x9d, 0x1d, 0x65,
-       0x9e, 0x05, 0x90, 0xff, 0x33, 0xe2, 0xd3, 0x46,
-       0xbb, 0xdb, 0xbc, 0x6c, 0x94, 0x6b, 0x15, 0xe1,
-       0xc7, 0x45, 0xa8, 0xb1, 0xf1, 0x43, 0x63, 0x78,
-       0x1a, 0xfa, 0xbf, 0xd1, 0x95, 0xbc, 0xe6, 0xa3,
-       0x4b, 0x79, 0xcd, 0xe3, 0x6b, 0xbb, 0x26, 0x91,
-       0x95, 0x37, 0x67, 0x68, 0x2e, 0xb7, 0x74, 0x7d,
-       0xfc, 0x39, 0x94, 0x76, 0x75, 0x4f, 0xdd, 0x82,
-       0x77, 0xa2, 0xc7, 0xb5, 0x3c, 0x5e, 0x3b, 0x16,
-       0xff, 0xde, 0x41, 0xa9, 0x20, 0x03, 0xac, 0xa3,
-       0xf1, 0xf8, 0x96, 0xe7, 0xb2, 0x21, 0x0b, 0xb6,
-       0xd2, 0x98, 0x9c, 0xea, 0x28, 0x93, 0xe0, 0xea,
-       0xf1, 0x40, 0xa2, 0x26, 0x67, 0xa9, 0xb3, 0xf7,
-       0x9b, 0x7b, 0xc3, 0x4a, 0x79, 0x16, 0xbc, 0xb6,
-       0x7e, 0xf9, 0x19, 0xed, 0xcd, 0x87, 0x52, 0x36,
-       0xea, 0x0a, 0xa6, 0xf9, 0x61, 0x1a, 0x79, 0x85,
-       0x0b, 0xef, 0xee, 0xa3, 0x71, 0x57, 0x18, 0x2c,
-       0x6d, 0xc8, 0x59, 0x48, 0x6f, 0x41, 0x38, 0x70,
-       0x0c, 0xbd, 0xba, 0xc9, 0x99, 0x4a, 0x7b, 0xb0,
-       0x85, 0xb7, 0xe9, 0xcd, 0x08, 0x0b, 0xf6, 0x0e,
-       0xd0, 0x0b, 0x09, 0xb1, 0xf2, 0x55, 0x69, 0xef,
-       0x36, 0xb0, 0xbb, 0xd8, 0x8b, 0x91, 0x52, 0x2c,
-       0x5e, 0xfa, 0xfc, 0xf7, 0x1c, 0xb0, 0xb4, 0x5e,
-       0x2a, 0x6b, 0xea, 0xe5, 0x6c, 0x70, 0xa0, 0x1d,
-       0x5d, 0x2d, 0x08, 0x80, 0x26, 0xab, 0xe5, 0x89,
-       0xde, 0xf5, 0x0e, 0x57, 0x36, 0xae, 0x3d, 0xaf,
-       0x8e, 0x1f, 0x2a, 0x79, 0xcb, 0x8a, 0x93, 0xe1,
-       0x49, 0x07, 0xa9, 0xe6, 0xf1, 0x6f, 0x40, 0xdc,
-       0xfa, 0x1e, 0xe5, 0x89, 0x72, 0x5e, 0x92, 0x61,
-       0xd4, 0x05, 0x66, 0x45, 0x95, 0x24, 0xef, 0x0f,
-       0x67, 0x51, 0xff, 0x85, 0x43, 0xfa, 0x87, 0x13,
-       0x38, 0xe2, 0x66, 0xbe, 0x4b, 0x96, 0x52, 0xc9,
-       0x46, 0xca, 0x4a, 0xfe, 0x14, 0x51, 0xe9, 0x42,
-       0x19, 0xb8, 0xbe, 0x99, 0xb0, 0x92, 0x61, 0x6b,
-       0x11, 0x7b, 0x4c, 0x84, 0x57, 0x57, 0x4b, 0x32,
-       0x7f, 0x2b, 0x67, 0xf8, 0x4c, 0x2c, 0xb5, 0x1c,
-       0x73, 0x59, 0x1f, 0xdf, 0x7a, 0xd4, 0x72, 0x82,
-       0x35, 0x36, 0x83, 0x69, 0xc4, 0x9f, 0xac, 0xcd,
-       0x60, 0x26, 0x3c, 0x4f, 0x6d, 0xfa, 0x87, 0xc5,
-       0x2c, 0xf6, 0x2d, 0x81, 0x9d, 0x68, 0x24, 0x84,
-       0x27, 0xf2, 0xd1, 0xc7, 0x8c, 0x3f, 0x9e, 0xee,
-       0x97, 0x38, 0x37, 0x1e, 0x74, 0x3c, 0x54, 0xc8,
-       0xeb, 0x7f, 0x24, 0xa8, 0xb7, 0x8d, 0xc3, 0xb4,
-       0xcd, 0xbc, 0x0d, 0x6a, 0x4a, 0xe4, 0x7e, 0xad,
-       0xae, 0x69, 0xe7, 0x63, 0x36, 0xf0, 0xa4, 0x66,
-       0x03, 0x7b, 0x7a, 0x71, 0x2d, 0xb0, 0x92, 0xde,
-       0xeb, 0x1d, 0xe5, 0xf9, 0x80, 0xbd, 0xdf, 0x3b,
-       0x6a, 0x9a, 0x0a, 0xf3, 0x3e, 0xe8, 0xce, 0x80,
-       0x60, 0x0a, 0x9b, 0xff, 0x7f, 0xc4, 0xc7, 0x33,
-       0xbc, 0x4e, 0x92, 0x71, 0xac, 0x1f, 0xb3, 0x46,
-       0x06, 0xdd, 0x76, 0x07, 0x04, 0xa9, 0x15, 0x0f,
-       0xb3, 0x99, 0x8c, 0x29, 0x38, 0x0a, 0xc3, 0xaf,
-       0x63, 0xb8, 0x58, 0xf6, 0x20, 0xc7, 0x12, 0xe4,
-       0x08, 0x3b, 0xc0, 0x6a, 0x87, 0x6c, 0x9a, 0xe5,
-       0x48, 0x90, 0x7c, 0x06, 0xe3, 0xea, 0x90, 0x4f,
-       0x4f, 0xa7, 0xd0, 0xb1, 0x33, 0xca, 0x4c, 0xc1,
-       0x34, 0xfa, 0x26, 0x0e, 0x86, 0x6b, 0x30, 0x3c,
-       0x12, 0xc3, 0x6b, 0x44, 0xd0, 0xf9, 0x82, 0x3a,
-       0x91, 0x66, 0x44, 0x13, 0xe5, 0x3c, 0x94, 0x93,
-       0x8a, 0x72, 0x8a, 0x54, 0x39, 0xe3, 0x99, 0x9c,
-       0xad, 0x4c, 0x8e, 0x31, 0x98, 0x24, 0x56, 0x31,
-       0x29, 0xc6, 0xa0, 0x45, 0x44, 0xff, 0xa0, 0x4b,
-       0x09, 0x9a, 0xc5, 0x62, 0xa4, 0xcc, 0x90, 0x71,
-       0xd5, 0x91, 0x72, 0x12, 0xd3, 0x81, 0x9a, 0x2e,
-       0x95, 0xa5, 0xab, 0x57, 0xd3, 0x59, 0x45, 0xca,
-       0xf5, 0x6c, 0x70, 0x84, 0x98, 0x5c, 0xd3, 0x1d,
-       0xc4, 0xb5, 0x5f, 0x4a, 0x0f, 0x5a, 0xfe, 0x31,
-       0x07, 0xcd, 0xbf, 0xb7, 0xb5, 0xed, 0xa9, 0xfe,
-       0xb6, 0xef, 0x6e, 0xec, 0xb5, 0x00, 0x2f, 0xed,
-       0xfa, 0x3e, 0xfa, 0xa1, 0xfe, 0xc2, 0xbb, 0xc1,
-       0x74, 0xb0, 0x0b, 0xa2, 0x3b, 0x4b, 0xe4, 0xb3,
-       0xf6, 0xef, 0x10, 0xcf, 0x52, 0xff, 0x51, 0xf7,
-       0x6a, 0x18, 0x9b, 0x6f, 0x83, 0xd7, 0x8a, 0xc1,
-       0xb4, 0xdc, 0x2b, 0xa7, 0x0b, 0xd6, 0xda, 0x70,
-       0xa6, 0xf1, 0xe9, 0xf0, 0x6e, 0xea, 0x33, 0x8f,
-       0xb4, 0x01, 0x6c, 0xd9, 0x4d, 0xe3, 0x69, 0x78,
-       0x39, 0xae, 0x9c, 0x6e, 0x2b, 0x01, 0x9d, 0x58,
-       0x2a, 0x58, 0x17, 0xc4, 0x38, 0x1e, 0x89, 0xb6,
-       0xad, 0xa0, 0xf8, 0x30, 0x2c, 0x6f, 0xa3, 0xd8,
-       0xd3, 0xb3, 0xf1, 0xaa, 0x17, 0x05, 0x94, 0x96,
-       0x20, 0x5b, 0x57, 0xeb, 0xd4, 0x13, 0xce, 0xf4,
-       0xab, 0xf5, 0x25, 0x17, 0x30, 0xad, 0x31, 0xe5,
-       0xc0, 0xe9, 0x27, 0xe6, 0xfd, 0x3c, 0x3a, 0x10,
-       0x00, 0x5b, 0xbe, 0x8d, 0xee, 0x47, 0x24, 0xca,
-       0xce, 0x80, 0x5e, 0xe5, 0xca, 0x0c, 0x18, 0xc4,
-       0xf4, 0x9d, 0x74, 0x87, 0xc0, 0x14, 0x1c, 0x23,
-       0x42, 0xb4, 0xd8, 0x47, 0x6d, 0x61, 0xc3, 0x50,
-       0x1e, 0x59, 0xe4, 0xd2, 0x22, 0x7a, 0xb2, 0x1f,
-       0xc0, 0x91, 0x66, 0xfc, 0x35, 0xd6, 0xb7, 0xb6,
-       0x2d, 0x15, 0x90, 0x72, 0x3a, 0x00, 0xe2, 0x85,
-       0xb9, 0x9d, 0xec, 0x03, 0x18, 0xfc, 0xd9, 0x36,
-       0x7b, 0xfc, 0x26, 0xe4, 0xe4, 0xe4, 0x58, 0xe0,
-       0x26, 0x4f, 0xd6, 0x78, 0x04, 0xd0, 0xa9, 0xd6,
-       0xf1, 0xff, 0xf4, 0x06, 0xfa, 0x67, 0x30, 0x1a,
-       0x8c, 0x84, 0x81, 0x2e, 0x21, 0xd1, 0x84, 0xd7,
-       0x44, 0x46, 0xd5, 0xe9, 0xe9, 0x84, 0x69, 0x36,
-       0x27, 0x64, 0xcf, 0x29, 0x97, 0x9e, 0x0c, 0xcc,
-       0x8c, 0x9d, 0xef, 0x66, 0xa4, 0xf3, 0xdd, 0xec,
-       0x87, 0xe2, 0xcf, 0x8b, 0x26, 0x6e, 0x36, 0x6b,
-       0xe4, 0xdc, 0x1f, 0xdc, 0xc0, 0xbd, 0x35, 0x9e,
-       0xbb, 0xf0, 0x6b, 0x45, 0xce, 0x3c, 0xbc, 0xe4,
-       0x16, 0xa2, 0xfd, 0x06, 0xe2, 0xfb, 0xc6, 0x1a,
-       0x9d, 0x2d, 0x95, 0xb5, 0x64, 0x84, 0xb5, 0xa3,
-       0xb5, 0x67, 0x8c, 0x62, 0xac, 0xfe, 0xb6, 0x78,
-       0x49, 0xb2, 0xe3, 0xf8, 0x34, 0x38, 0x73, 0xe6,
-       0x4c, 0x21, 0xa0, 0xe3, 0x77, 0x82, 0x84, 0xc4,
-       0xca, 0x53, 0xc9, 0xa8, 0x95, 0x92, 0x5f, 0x83,
-       0xde, 0xf6, 0x4b, 0xf6, 0x0f, 0x7b, 0x8c, 0x13,
-       0xdb, 0x3b, 0x82, 0xed, 0xfd, 0xa1, 0xb7, 0xea,
-       0xc7, 0xb0, 0x98, 0x30, 0xf4, 0xba, 0xa3, 0x94,
-       0x0c, 0x5b, 0x36, 0xe8, 0x22, 0xd4, 0x0b, 0xc6,
-       0xd2, 0x5d, 0xb3, 0x65, 0x57, 0x6d, 0xbf, 0xa4,
-       0x77, 0x22, 0x58, 0x2b, 0x4c, 0xa1, 0xbb, 0xc4,
-       0xd1, 0x94, 0xaa, 0x4e, 0xe4, 0x4c, 0x56, 0xd2,
-       0x63, 0x9c, 0x76, 0xe2, 0x6c, 0x4d, 0xba, 0x81,
-       0x33, 0x8d, 0xbe, 0xc7, 0x45, 0xb6, 0xce, 0x7e,
-       0x4f, 0xe2, 0xef, 0x05, 0xea, 0x3b, 0xf8, 0xc3,
-       0x59, 0x19, 0x5c, 0x43, 0x5b, 0x46, 0x0b, 0xd5,
-       0x15, 0xe2, 0xaf, 0x12, 0x7f, 0x4b, 0xf1, 0xd7,
-       0x8d, 0x3f, 0x9c, 0x77, 0xe9, 0x0e, 0xe1, 0xef,
-       0xb4, 0x08, 0x7a, 0x33, 0xfe, 0x2c, 0xf8, 0x2b,
-       0xc6, 0x9f, 0x1f, 0x7f, 0xd5, 0xf8, 0x43, 0x3e,
-       0x3d, 0xf2, 0xe9, 0x5f, 0xe6, 0xfb, 0x77, 0xdd,
-       0xd9, 0x75, 0xd9, 0x8b, 0xa6, 0x15, 0xd5, 0xb7,
-       0x84, 0x20, 0x9e, 0x90, 0x5b, 0x48, 0x14, 0xba,
-       0x6b, 0x36, 0x89, 0xfc, 0x0c, 0x95, 0xd5, 0xff,
-       0x2d, 0x7a, 0xef, 0xf0, 0xf6, 0xc2, 0x77, 0xf7,
-       0xe1, 0x1a, 0x65, 0x38, 0x2d, 0x9d, 0x79, 0x91,
-       0x6c, 0xfc, 0xd5, 0xb1, 0x38, 0xc7, 0x75, 0xf1,
-       0x7a, 0x16, 0x3f, 0xf9, 0x66, 0x71, 0x63, 0x3f,
-       0x1a, 0x4a, 0xfb, 0xb9, 0x3c, 0xfb, 0x79, 0x7a,
-       0x95, 0x6f, 0x11, 0xe3, 0xb9, 0xff, 0x3a, 0x9e,
-       0x67, 0x19, 0xcf, 0x03, 0x37, 0x8d, 0x5b, 0xc7,
-       0xe3, 0x86, 0xa5, 0xa7, 0x78, 0xfd, 0x07, 0x5e,
-       0xe2, 0xaa, 0xfd, 0x16, 0x8d, 0x38, 0x63, 0x97,
-       0xc4, 0xd5, 0x6c, 0x78, 0x8c, 0xe7, 0xba, 0xfa,
-       0xdd, 0xc8, 0x21, 0xc4, 0x38, 0x86, 0xa4, 0x1b,
-       0xd0, 0x43, 0x12, 0x1f, 0x5d, 0x75, 0x0b, 0xbe,
-       0x15, 0x34, 0xe1, 0xc8, 0x7d, 0x35, 0x2e, 0x8f,
-       0x9b, 0xc5, 0x1f, 0xbf, 0x49, 0x4e, 0x6a, 0x2d,
-       0x6e, 0xdb, 0x1b, 0x8b, 0xab, 0xb9, 0x99, 0x96,
-       0x6e, 0x7b, 0x66, 0x28, 0xfe, 0x06, 0x6d, 0xb9,
-       0xd9, 0x95, 0xb5, 0x25, 0xf7, 0x08, 0xb2, 0x2d,
-       0x2e, 0x65, 0x3d, 0x2b, 0xd5, 0x75, 0x75, 0xba,
-       0xad, 0x92, 0xa8, 0xe4, 0xb3, 0x52, 0x18, 0xa7,
-       0x77, 0xad, 0x77, 0x5f, 0xef, 0x5a, 0x56, 0xca,
-       0x3c, 0x8a, 0xa1, 0xb8, 0x05, 0x14, 0xa7, 0xff,
-       0xa0, 0x22, 0x85, 0xa5, 0x8a, 0xc5, 0xa7, 0xa8,
-       0xb5, 0x74, 0xdc, 0x4c, 0x57, 0xf6, 0xcb, 0x37,
-       0xb1, 0x86, 0xe1, 0x1c, 0x47, 0x6f, 0x62, 0x13,
-       0x71, 0x35, 0xb5, 0xef, 0x8c, 0xd7, 0xf6, 0x19,
-       0xa8, 0x29, 0xab, 0xc6, 0xe9, 0x70, 0x0b, 0xb8,
-       0x4b, 0x4b, 0xd0, 0x64, 0x9b, 0x38, 0xd4, 0x75,
-       0x72, 0xa8, 0x0f, 0x72, 0x68, 0x90, 0x38, 0x34,
-       0x7e, 0x9d, 0xc3, 0x04, 0x85, 0x43, 0xd3, 0xc3,
-       0x1c, 0x26, 0x2e, 0xe7, 0xd0, 0xfc, 0x57, 0x1c,
-       0x26, 0xad, 0xe2, 0xd0, 0xd2, 0xce, 0xe1, 0x88,
-       0x47, 0x38, 0xb4, 0x36, 0x70, 0x38, 0xb2, 0x83,
-       0xc3, 0xe4, 0xc9, 0xa8, 0xdc, 0x52, 0xcc, 0xf7,
-       0x4e, 0x0e, 0x75, 0x5f, 0xe3, 0x50, 0x9f, 0xc7,
-       0xa1, 0x61, 0x22, 0x87, 0xc6, 0x5c, 0x0e, 0x13,
-       0xee, 0xe2, 0xd0, 0x74, 0x0f, 0x87, 0x89, 0x53,
-       0x38, 0x34, 0x4f, 0xe7, 0x30, 0xe9, 0x5e, 0x0e,
-       0x2d, 0x53, 0x39, 0x1c, 0x31, 0x93, 0x43, 0xeb,
-       0x24, 0x0e, 0x47, 0xe6, 0x73, 0x98, 0x6c, 0x01,
-       0x77, 0x4d, 0x25, 0xfa, 0x1c, 0x13, 0x87, 0xba,
-       0x34, 0x0e, 0xf5, 0xc9, 0x1c, 0x9a, 0xc7, 0x73,
-       0x98, 0xf4, 0x38, 0x78, 0x2a, 0x6a, 0xb1, 0x7c,
-       0x19, 0x1c, 0xea, 0x0a, 0x38, 0xd4, 0x67, 0x73,
-       0x68, 0x2e, 0xe6, 0x30, 0xe9, 0x4d, 0x28, 0x99,
-       0x53, 0x8d, 0x7c, 0x3f, 0xe5, 0x50, 0xf7, 0x2f,
-       0x1c, 0xea, 0x8f, 0x72, 0x68, 0xd8, 0xc7, 0xa1,
-       0xf1, 0x5d, 0x0e, 0x13, 0x7e, 0xc6, 0xa1, 0xe9,
-       0x5f, 0x39, 0x4c, 0xfc, 0x39, 0x87, 0xe6, 0x7f,
-       0xe7, 0x30, 0xe9, 0x97, 0x1c, 0x5a, 0xde, 0xe1,
-       0x70, 0xc4, 0x29, 0x0e, 0xad, 0x6f, 0x70, 0x38,
-       0xf2, 0x17, 0x1c, 0x26, 0x9f, 0x86, 0x12, 0x3a,
-       0x0c, 0xce, 0x76, 0x96, 0x43, 0xdd, 0x05, 0x0e,
-       0xcd, 0x11, 0x84, 0x8b, 0x90, 0x7e, 0x80, 0x43,
-       0xdd, 0x11, 0x0e, 0xcd, 0xd3, 0xa0, 0xb4, 0x0c,
-       0xf5, 0x3e, 0xea, 0x20, 0x87, 0xba, 0xf7, 0x38,
-       0xd4, 0xbf, 0xcd, 0xa1, 0xf9, 0x7d, 0x0e, 0x93,
-       0x2a, 0xa0, 0x8c, 0xce, 0xbe, 0xb2, 0x95, 0x71,
-       0xa8, 0x9b, 0xcf, 0xa1, 0xde, 0xcf, 0xa1, 0xc1,
-       0xcd, 0xa1, 0x71, 0x1e, 0x87, 0x09, 0xb3, 0x38,
-       0x34, 0x2d, 0xe4, 0x30, 0x71, 0x0e, 0x87, 0xe6,
-       0x07, 0x38, 0x4c, 0x5a, 0xc4, 0xa1, 0x65, 0x2e,
-       0x87, 0x23, 0x1e, 0xe2, 0xd0, 0x5a, 0xc2, 0xe1,
-       0xc8, 0x1a, 0x0e, 0x93, 0xc7, 0x42, 0x45, 0x15,
-       0x95, 0xef, 0x23, 0x0e, 0x75, 0x57, 0x38, 0xd4,
-       0x5f, 0xe4, 0xd0, 0x7c, 0x8d, 0xc3, 0xa4, 0xef,
-       0x41, 0x65, 0xa9, 0x1b, 0xcb, 0xf7, 0xbf, 0x38,
-       0xd4, 0xfd, 0x90, 0x43, 0xfd, 0x4e, 0x0e, 0x0d,
-       0xdb, 0x38, 0x34, 0xbe, 0xc2, 0x61, 0xc2, 0x3f,
-       0x72, 0x68, 0xfa, 0x11, 0x87, 0x89, 0xff, 0x9b,
-       0x43, 0xf3, 0x3f, 0x73, 0x98, 0xf4, 0x2a, 0x87,
-       0x96, 0x7f, 0xe2, 0x70, 0xc4, 0x4f, 0x38, 0xb4,
-       0xfe, 0x03, 0x87, 0x23, 0x7f, 0xc0, 0x61, 0xf2,
-       0x76, 0x84, 0xa4, 0xef, 0x17, 0x38, 0xd4, 0xed,
-       0xe6, 0x30, 0xed, 0x65, 0x0e, 0xcd, 0xaf, 0x73,
-       0x68, 0x79, 0x0e, 0x21, 0xe9, 0xff, 0x79, 0x0e,
-       0x75, 0xbb, 0x38, 0xd4, 0xbf, 0xc4, 0xa1, 0x79,
-       0x2f, 0x87, 0x49, 0xe5, 0x50, 0x59, 0x43, 0xfa,
-       0x5d, 0xc0, 0xa1, 0xbe, 0x8a, 0x43, 0xf3, 0x83,
-       0x1c, 0x26, 0xf9, 0x38, 0x1c, 0x95, 0x04, 0x73,
-       0xfd, 0x54, 0xdf, 0x04, 0x0e, 0x75, 0xb7, 0x70,
-       0xa8, 0x4f, 0xe1, 0xd0, 0xa0, 0xe3, 0xd0, 0x38,
-       0x9a, 0xc3, 0x84, 0x44, 0x0e, 0x4d, 0xb7, 0x72,
-       0x98, 0x38, 0x92, 0x43, 0xf3, 0x1d, 0x1c, 0x26,
-       0xdd, 0xc6, 0xa1, 0x65, 0x14, 0x87, 0x23, 0x26,
-       0x70, 0x68, 0x35, 0x70, 0x38, 0x72, 0x0c, 0x87,
-       0xc9, 0x59, 0xe0, 0x9f, 0x4b, 0xfd, 0x24, 0x93,
-       0x43, 0x5d, 0x21, 0x87, 0xfa, 0x1c, 0x0e, 0xcd,
-       0x33, 0x38, 0x4c, 0x5a, 0x8a, 0x90, 0xca, 0x29,
-       0x73, 0xa8, 0x5b, 0xc1, 0xa1, 0xbe, 0x8d, 0x43,
-       0xf3, 0x1a, 0x0e, 0x93, 0xce, 0x41, 0x8d, 0x87,
-       0xfc, 0xcc, 0x87, 0x1c, 0xea, 0x7e, 0xcf, 0xa1,
-       0xfe, 0x12, 0x87, 0x86, 0x0f, 0x38, 0x34, 0x7e,
-       0xc2, 0x61, 0xc2, 0xc7, 0x1c, 0x9a, 0xfe, 0xc0,
-       0x61, 0xe2, 0x6f, 0x38, 0x34, 0x7f, 0xc6, 0x61,
-       0xd2, 0xa7, 0x1c, 0x5a, 0x7e, 0xcb, 0xe1, 0x88,
-       0x28, 0x87, 0xd6, 0x5f, 0x71, 0x38, 0xf2, 0x77,
-       0x1c, 0x26, 0x7f, 0x13, 0x6a, 0x6a, 0x49, 0x6f,
-       0x7f, 0xcb, 0xa1, 0x7e, 0x13, 0x87, 0x86, 0xb5,
-       0x1c, 0x1a, 0x9f, 0xe2, 0x30, 0xe1, 0x5b, 0x1c,
-       0x9a, 0xbe, 0xcb, 0x61, 0xe2, 0x5f, 0x73, 0x68,
-       0xfe, 0x1f, 0x1c, 0x26, 0xfd, 0x1d, 0x87, 0x96,
-       0xbf, 0xe1, 0x70, 0xc4, 0xff, 0xe4, 0xd0, 0xfa,
-       0x28, 0x87, 0x23, 0xbf, 0xc3, 0x61, 0xf2, 0x7a,
-       0x84, 0x64, 0x1f, 0x4f, 0x73, 0x98, 0xf6, 0x24,
-       0x87, 0xe6, 0xc7, 0x10, 0x92, 0x3d, 0x6c, 0xe6,
-       0x50, 0xff, 0x04, 0x87, 0xe6, 0x46, 0x84, 0x8b,
-       0x91, 0x1e, 0xe2, 0x50, 0xff, 0x0c, 0x87, 0xe6,
-       0x67, 0x39, 0x4c, 0x4a, 0x85, 0x5a, 0xbf, 0x07,
-       0xe3, 0xc7, 0x71, 0x68, 0x36, 0x42, 0x6d, 0x0d,
-       0xe1, 0x56, 0x0e, 0xcd, 0xfb, 0xc1, 0x8f, 0x7e,
-       0xdc, 0x05, 0x9a, 0x3f, 0xdf, 0x08, 0x9e, 0x12,
-       0xac, 0xf7, 0xe8, 0x1e, 0x84, 0x35, 0x08, 0xfb,
-       0xc1, 0x53, 0x36, 0x0f, 0xa1, 0x13, 0x3c, 0x73,
-       0x2a, 0x10, 0xf6, 0x82, 0xa7, 0xaa, 0x0c, 0xa1,
-       0x0d, 0x3c, 0xd5, 0xd8, 0x7e, 0xa3, 0xc3, 0xe0,
-       0xa1, 0xf6, 0x1e, 0x5d, 0x0d, 0x9e, 0x05, 0x94,
-       0x2e, 0x80, 0x90, 0xd2, 0xd9, 0xa1, 0xa4, 0x12,
-       0xf1, 0x94, 0xe3, 0x08, 0xd1, 0x6f, 0xa6, 0xd4,
-       0x21, 0xc4, 0xf4, 0x29, 0x7b, 0x10, 0x2e, 0x40,
-       0x78, 0x18, 0xfd, 0x05, 0xd6, 0x2b, 0xa5, 0x1b,
-       0x21, 0xd6, 0x23, 0xa5, 0x0f, 0xfb, 0x27, 0xe1,
-       0x87, 0x10, 0x12, 0x7e, 0x1e, 0xaa, 0xe8, 0x94,
-       0xbf, 0x94, 0xcb, 0x50, 0x5d, 0x46, 0x7a, 0x3c,
-       0x86, 0x10, 0xd3, 0x1b, 0xea, 0x11, 0xa2, 0x3d,
-       0x8c, 0xf1, 0x42, 0xb5, 0x17, 0xe9, 0x29, 0xdf,
-       0x46, 0x88, 0xf5, 0x48, 0x19, 0x81, 0x90, 0xf2,
-       0x99, 0x8d, 0x70, 0x36, 0x42, 0x33, 0x42, 0x4a,
-       0x7f, 0x02, 0x21, 0xc9, 0x5d, 0x8c, 0x90, 0xe4,
-       0x36, 0x43, 0x35, 0x1d, 0xf1, 0x98, 0xf2, 0x7d,
-       0x84, 0x94, 0xee, 0x6e, 0x84, 0x94, 0xce, 0x81,
-       0x90, 0xf8, 0x07, 0x10, 0x12, 0xff, 0x6a, 0x84,
-       0xc4, 0x5f, 0x84, 0x7a, 0xa1, 0x7a, 0x5c, 0x45,
-       0x48, 0x7c, 0x2b, 0x11, 0x52, 0x3d, 0x5e, 0x84,
-       0x5a, 0x37, 0xf1, 0xed, 0x40, 0x48, 0x7c, 0xf7,
-       0x43, 0x2d, 0x1d, 0x59, 0x99, 0x72, 0x3b, 0x42,
-       0xac, 0x7f, 0xca, 0x37, 0xa0, 0x96, 0xc6, 0xa9,
-       0x14, 0x4d, 0xef, 0x5a, 0x3b, 0x68, 0x7a, 0xd7,
-       0xda, 0xe1, 0x3e, 0x60, 0x07, 0x17, 0xa6, 0xbc,
-       0x86, 0x90, 0xe4, 0x6d, 0x80, 0xda, 0x3a, 0x2a,
-       0xdf, 0x56, 0x84, 0x24, 0xe7, 0xef, 0x11, 0x92,
-       0xfc, 0x2d, 0x50, 0xbb, 0x88, 0xe8, 0x3f, 0x46,
-       0x48, 0x7c, 0x7f, 0x84, 0xba, 0x12, 0x6c, 0x87,
-       0x14, 0x40, 0xfd, 0xd3, 0x11, 0x7d, 0xeb, 0x10,
-       0x62, 0x7b, 0x8c, 0xd1, 0xab, 0xa7, 0x23, 0x9e,
-       0x04, 0xdf, 0x1c, 0xc4, 0x53, 0x2b, 0x11, 0xd2,
-       0xf8, 0xd0, 0xca, 0x61, 0x6a, 0x17, 0x87, 0xb7,
-       0x2c, 0xe1, 0x70, 0x44, 0x3a, 0xf8, 0x68, 0xbc,
-       0x1a, 0x21, 0x20, 0xa4, 0xfe, 0x36, 0xc8, 0xe1,
-       0x2d, 0xb5, 0x30, 0x67, 0x41, 0x15, 0xe2, 0xa5,
-       0x08, 0xab, 0xe3, 0xec, 0xc4, 0x05, 0xfe, 0x5a,
-       0xaa, 0xff, 0x32, 0x84, 0x98, 0x2e, 0x45, 0x44,
-       0x48, 0xe5, 0xd4, 0xec, 0xe7, 0xdf, 0xd0, 0xee,
-       0x48, 0x8f, 0x6f, 0xc1, 0x42, 0x37, 0xf1, 0xfd,
-       0x1a, 0xea, 0x3c, 0x54, 0xee, 0x68, 0x94, 0xdd,
-       0x3b, 0x98, 0x25, 0x81, 0x19, 0xd7, 0xa5, 0xdf,
-       0x63, 0xcf, 0x02, 0xd3, 0x1e, 0x95, 0x20, 0xf1,
-       0x12, 0x62, 0x7d, 0x0c, 0x6b, 0x43, 0xec, 0x2c,
-       0x62, 0x27, 0xb4, 0xbb, 0x0c, 0x89, 0xef, 0x21,
-       0x76, 0x84, 0x61, 0x7f, 0x8b, 0x18, 0xce, 0xaf,
-       0xbf, 0xf7, 0x3a, 0xc3, 0x5e, 0x40, 0xec, 0x35,
-       0xc4, 0x7a, 0x18, 0xf6, 0x2a, 0x62, 0x2f, 0x21,
-       0xb6, 0x9d, 0x61, 0xbf, 0x42, 0xec, 0x59, 0xc4,
-       0x36, 0x33, 0xac, 0x17, 0xb1, 0x8d, 0x88, 0xad,
-       0xc7, 0x95, 0x99, 0xb4, 0xdc, 0x82, 0xd7, 0xd5,
-       0x6d, 0xc6, 0xde, 0x62, 0x38, 0x5d, 0xd5, 0x49,
-       0x2b, 0x63, 0x46, 0x59, 0xcc, 0x28, 0x42, 0x55,
-       0xe7, 0x4e, 0xc6, 0xb3, 0x93, 0xf1, 0x1c, 0x65,
-       0x3c, 0xf4, 0x4d, 0x21, 0xed, 0x0d, 0x5e, 0xab,
-       0x0d, 0xee, 0x92, 0x05, 0x76, 0xd7, 0xdc, 0x41,
-       0x4f, 0xbe, 0x64, 0x33, 0xa3, 0x98, 0xfc, 0xdd,
-       0x29, 0x11, 0xf1, 0xbc, 0xe7, 0x36, 0xfe, 0x25,
-       0x20, 0x8c, 0xb5, 0xb0, 0xf5, 0xf8, 0x45, 0xa4,
-       0x5e, 0x22, 0x9a, 0x67, 0x34, 0xc9, 0x09, 0xc4,
-       0xe4, 0xb0, 0x75, 0xd4, 0x68, 0xb6, 0xf6, 0xb2,
-       0xa1, 0x84, 0x29, 0xea, 0xfd, 0x78, 0x9b, 0xbf,
-       0x3b, 0x04, 0x01, 0x40, 0xca, 0x24, 0x7e, 0x9a,
-       0x17, 0x4a, 0x71, 0xe2, 0x1a, 0x95, 0x56, 0xe6,
-       0xf7, 0xe2, 0xaa, 0xf5, 0xc4, 0x46, 0xc4, 0x8f,
-       0xad, 0xcb, 0xd4, 0x7f, 0xb8, 0xe1, 0xd8, 0xa3,
-       0xc7, 0xf8, 0xda, 0x6d, 0xb4, 0x78, 0x1c, 0xf9,
-       0xef, 0x94, 0xd3, 0x29, 0xad, 0xcd, 0x4e, 0x1c,
-       0xcb, 0x00, 0x7a, 0x30, 0x85, 0x0e, 0x53, 0xec,
-       0x38, 0xb6, 0xee, 0x31, 0x50, 0xf9, 0xce, 0xb0,
-       0xb2, 0x3a, 0x38, 0x9f, 0x02, 0xf0, 0x44, 0x5c,
-       0x0d, 0xcc, 0xfe, 0xee, 0x0f, 0x36, 0xa4, 0x82,
-       0xf8, 0x91, 0xbf, 0x5b, 0xe5, 0x6e, 0x45, 0xfa,
-       0x12, 0xd9, 0xe8, 0xef, 0x16, 0x2d, 0xe9, 0x5e,
-       0x36, 0x73, 0x4d, 0x91, 0xc7, 0x49, 0x01, 0x5f,
-       0x58, 0x49, 0xe3, 0x1c, 0x53, 0xad, 0x74, 0x1f,
-       0xe6, 0xa3, 0x25, 0x19, 0xa9, 0x0e, 0xda, 0x55,
-       0x55, 0x2c, 0x54, 0x60, 0x8a, 0x0c, 0x92, 0x5f,
-       0xc2, 0x9e, 0x93, 0xd1, 0x9a, 0xfe, 0xda, 0x93,
-       0xc1, 0x51, 0x3d, 0xb9, 0x36, 0x58, 0xf8, 0x66,
-       0x74, 0xc0, 0xe7, 0x5e, 0x66, 0x3f, 0xb7, 0xe1,
-       0x31, 0xb7, 0x2a, 0xff, 0x04, 0x93, 0x39, 0x46,
-       0x81, 0xe8, 0x58, 0xf1, 0xed, 0x9a, 0x6e, 0x81,
-       0xaf, 0x97, 0x6d, 0x8a, 0xbe, 0x94, 0x3f, 0x0b,
-       0x18, 0x8d, 0x7a, 0x4b, 0x66, 0x5a, 0x5b, 0x99,
-       0x69, 0x56, 0x79, 0x93, 0x4b, 0x06, 0x74, 0x8e,
-       0x54, 0x47, 0x34, 0xba, 0xab, 0x98, 0xca, 0x56,
-       0x32, 0x00, 0x8b, 0x43, 0xe0, 0x1b, 0xad, 0xa4,
-       0xd3, 0x6e, 0xb0, 0x60, 0xa2, 0x6d, 0x2c, 0xe6,
-       0x38, 0xae, 0xe7, 0x76, 0xd9, 0xea, 0x1b, 0x83,
-       0x39, 0x5e, 0xca, 0x98, 0x0c, 0x66, 0x87, 0xaf,
-       0xe4, 0x1c, 0x58, 0xc5, 0x13, 0x42, 0xa5, 0xcd,
-       0xa6, 0xa4, 0x49, 0xf0, 0xd9, 0x20, 0xad, 0xf9,
-       0x56, 0x6d, 0xec, 0xb9, 0x4d, 0x31, 0xfb, 0x46,
-       0xcb, 0x57, 0x71, 0xf1, 0x55, 0x22, 0xe8, 0x71,
-       0xf5, 0x8d, 0x79, 0x59, 0x84, 0xbb, 0xa7, 0x64,
-       0x4d, 0xcd, 0xec, 0x9a, 0x9c, 0xf3, 0x00, 0x94,
-       0x6a, 0x27, 0xba, 0x6e, 0x9f, 0xb1, 0xab, 0x34,
-       0x37, 0x16, 0xde, 0x53, 0x9a, 0x17, 0x0b, 0xef,
-       0x2d, 0xcd, 0x8f, 0x85, 0x23, 0xa5, 0x05, 0xb1,
-       0xf0, 0x81, 0xd2, 0xaf, 0xc5, 0xc2, 0x87, 0x4a,
-       0x0b, 0x63, 0xe1, 0x23, 0xa5, 0xf7, 0xc4, 0xc2,
-       0xbd, 0xee, 0x21, 0xf9, 0xc7, 0xdc, 0x43, 0xf2,
-       0x8f, 0xbb, 0x87, 0xe4, 0x9f, 0x74, 0x0f, 0xc9,
-       0x3f, 0xed, 0x1e, 0x92, 0x7f, 0xd6, 0x3d, 0x24,
-       0xbf, 0xcf, 0x3d, 0x24, 0xff, 0x82, 0x7b, 0x48,
-       0x7e, 0x7f, 0x75, 0x49, 0x2c, 0x7c, 0x65, 0x81,
-       0x47, 0x3d, 0xa2, 0x92, 0x76, 0x3f, 0xbb, 0x4b,
-       0xfc, 0x6a, 0xd8, 0x54, 0xe2, 0x76, 0x6b, 0x61,
-       0x4b, 0x75, 0x49, 0x8c, 0x27, 0x85, 0x7d, 0x9d,
-       0x4f, 0xa5, 0x57, 0x68, 0x87, 0xdc, 0x6e, 0x9f,
-       0x99, 0x3c, 0x67, 0x28, 0x9c, 0x32, 0x3f, 0x16,
-       0x9e, 0x71, 0xad, 0xac, 0xae, 0x4c, 0xcb, 0xcd,
-       0x58, 0x59, 0xb6, 0x40, 0x2b, 0x35, 0x3b, 0xf3,
-       0x13, 0x6d, 0xc2, 0x21, 0xdb, 0xe8, 0x0c, 0x29,
-       0x78, 0x09, 0xad, 0x7f, 0xb2, 0x0c, 0x3a, 0x93,
-       0x98, 0x89, 0xd4, 0xfb, 0x65, 0x3b, 0xa3, 0x3e,
-       0x8d, 0xd4, 0x07, 0xe8, 0xed, 0x44, 0xb2, 0xa6,
-       0xb3, 0xc9, 0x42, 0xaa, 0x68, 0x96, 0x60, 0xf0,
-       0x18, 0x52, 0xde, 0x67, 0xa7, 0xda, 0xb9, 0xfc,
-       0xdd, 0x53, 0x75, 0x29, 0x68, 0x4b, 0x83, 0xf2,
-       0x4e, 0x3a, 0xc1, 0xdc, 0xea, 0x0d, 0x7b, 0x23,
-       0x7c, 0xbf, 0xaa, 0x98, 0x8e, 0x94, 0x85, 0x48,
-       0x89, 0x68, 0x4f, 0xb3, 0x45, 0xdb, 0x4e, 0xfe,
-       0x95, 0x85, 0xed, 0xf9, 0x6c, 0xb7, 0x74, 0x85,
-       0x23, 0x7d, 0x42, 0x55, 0xe7, 0x54, 0x1d, 0xae,
-       0xe9, 0x57, 0xa6, 0x03, 0xdb, 0xbf, 0x69, 0xa5,
-       0x5c, 0xa3, 0x4b, 0x31, 0xe7, 0x0d, 0xe2, 0x45,
-       0xa4, 0x4c, 0x55, 0x29, 0x75, 0x48, 0xd9, 0x21,
-       0x9e, 0x14, 0x74, 0x3c, 0x05, 0xc6, 0xdc, 0x2d,
-       0xeb, 0xfd, 0xdd, 0xbc, 0x77, 0x22, 0xc7, 0x6b,
-       0xa5, 0x61, 0x51, 0x2f, 0xed, 0x62, 0x52, 0xee,
-       0x66, 0x94, 0x1d, 0x47, 0xc3, 0xe2, 0xa5, 0x58,
-       0xfc, 0xd6, 0x4d, 0x61, 0xf1, 0x2c, 0x4f, 0x3d,
-       0xe9, 0x1d, 0xcc, 0x39, 0x75, 0xe8, 0xad, 0x7f,
-       0xc5, 0x22, 0xbd, 0x4c, 0xa7, 0x8f, 0x74, 0x99,
-       0xd8, 0x77, 0x6f, 0xb6, 0x75, 0x25, 0x56, 0x75,
-       0xd2, 0x17, 0xfb, 0x2a, 0x52, 0x03, 0xd1, 0xaa,
-       0x4e, 0xd0, 0x79, 0x3f, 0x7e, 0x8e, 0xed, 0x12,
-       0xa8, 0xb0, 0x7b, 0x7b, 0xc1, 0xe0, 0x75, 0xed,
-       0x8f, 0x14, 0xe8, 0x2a, 0x29, 0xe4, 0xde, 0x1f,
-       0x39, 0xe6, 0xf6, 0x7a, 0x3c, 0x1e, 0xc2, 0xf6,
-       0x47, 0x8e, 0xae, 0xab, 0x3c, 0xa5, 0x4b, 0xa0,
-       0x3e, 0xb1, 0x27, 0xbc, 0xcf, 0xed, 0x31, 0xfa,
-       0xc2, 0x4b, 0x8d, 0xa5, 0xe1, 0x72, 0xa3, 0x6f,
-       0x2d, 0xc2, 0xb5, 0xe5, 0x46, 0x7a, 0x5b, 0x89,
-       0xfb, 0xd8, 0x0a, 0x81, 0x24, 0x85, 0x60, 0x27,
-       0x7f, 0xfe, 0x38, 0xce, 0xe7, 0x56, 0x9e, 0xf4,
-       0xba, 0x22, 0x8f, 0x86, 0xf7, 0x15, 0x00, 0xc9,
-       0x73, 0x3a, 0x40, 0x1f, 0xde, 0x17, 0x41, 0x1f,
-       0x22, 0xda, 0xcf, 0x74, 0x9f, 0x79, 0x5c, 0xe5,
-       0xbb, 0x8c, 0x7c, 0x10, 0x95, 0x89, 0xeb, 0xc0,
-       0xa3, 0x3e, 0x23, 0xf6, 0xc5, 0x75, 0xe9, 0xd8,
-       0x37, 0x74, 0x77, 0x68, 0xfd, 0x90, 0xfa, 0x4e,
-       0xd7, 0xf9, 0x50, 0x34, 0xd6, 0xe7, 0x0c, 0xd4,
-       0xe7, 0x06, 0x76, 0x0c, 0xf5, 0xb9, 0x82, 0xc9,
-       0x60, 0x64, 0x7d, 0xce, 0x44, 0x7d, 0xce, 0xa9,
-       0xf6, 0x2c, 0xde, 0x9b, 0x58, 0x3f, 0xd2, 0xb1,
-       0x1e, 0xa4, 0x67, 0x7d, 0xc7, 0xc0, 0x7a, 0x8d,
-       0x91, 0xf5, 0x97, 0x04, 0xd6, 0x53, 0x4c, 0xac,
-       0x8f, 0x24, 0xb2, 0xde, 0x61, 0x66, 0xfd, 0x22,
-       0x89, 0xf5, 0x08, 0x0b, 0xeb, 0x0b, 0x23, 0x58,
-       0x2f, 0xb0, 0x32, 0xfb, 0x1f, 0xc9, 0x2c, 0x3f,
-       0x99, 0xd9, 0xfc, 0x28, 0x66, 0xed, 0x36, 0x66,
-       0xb5, 0xa3, 0x99, 0xb5, 0x73, 0xfb, 0x1c, 0x53,
-       0x43, 0xd7, 0x54, 0x66, 0xf3, 0xb7, 0x30, 0x0b,
-       0x4f, 0x63, 0xb6, 0x7d, 0x2b, 0xed, 0x14, 0x5f,
-       0x73, 0x95, 0x7d, 0x37, 0x9c, 0x9d, 0xfc, 0xc9,
-       0xdf, 0xb1, 0x74, 0x54, 0x94, 0x5d, 0x00, 0xf3,
-       0x64, 0x17, 0x18, 0x33, 0xbd, 0xf4, 0xf6, 0x69,
-       0x76, 0xc2, 0x5e, 0xba, 0x5f, 0x18, 0x6e, 0x37,
-       0x76, 0x3d, 0xe2, 0x5f, 0x2f, 0x98, 0x6a, 0xc2,
-       0xb2, 0x29, 0xf5, 0xb8, 0x67, 0xac, 0xb8, 0xc0,
-       0x66, 0x1f, 0xc3, 0xbe, 0x70, 0x94, 0x62, 0xdf,
-       0x09, 0xf2, 0xf8, 0x95, 0xba, 0x9a, 0xf5, 0xfe,
-       0xc7, 0x6a, 0xd6, 0x2b, 0xa6, 0x1e, 0x3b, 0xdd,
-       0x47, 0xde, 0xfa, 0x58, 0x69, 0x69, 0x6a, 0x24,
-       0xf5, 0x80, 0xef, 0x9b, 0x4a, 0xb6, 0xf8, 0x5a,
-       0x49, 0x5f, 0xf4, 0xda, 0x4a, 0xb0, 0xe9, 0x18,
-       0x87, 0x99, 0xa5, 0xb8, 0x54, 0xd3, 0x4d, 0x5c,
-       0x35, 0x8f, 0x39, 0x8d, 0xa9, 0xbf, 0x9c, 0x77,
-       0x24, 0x3a, 0x98, 0x1a, 0xf1, 0x7d, 0x53, 0xde,
-       0x28, 0x58, 0x4a, 0x30, 0xff, 0x8d, 0x8f, 0x3b,
-       0xc2, 0xbb, 0xc3, 0x6d, 0xe9, 0x14, 0x16, 0x0c,
-       0xa5, 0x61, 0x47, 0x58, 0x30, 0xa4, 0x18, 0xce,
-       0x7e, 0x3b, 0xfd, 0xdf, 0x6a, 0x1e, 0x95, 0x07,
-       0xf6, 0x77, 0x81, 0x41, 0xd4, 0xa7, 0xfc, 0x1b,
-       0x9d, 0x11, 0x5f, 0x1d, 0xbe, 0xfe, 0xed, 0xd0,
-       0xfc, 0xc1, 0xb5, 0xac, 0x46, 0x95, 0xa7, 0x26,
-       0xac, 0x61, 0x5f, 0x94, 0x39, 0x3d, 0xc4, 0xc1,
-       0xeb, 0xea, 0xdb, 0xb8, 0xac, 0xb0, 0xf2, 0x38,
-       0x18, 0x32, 0xbc, 0xef, 0x46, 0x7e, 0xb1, 0xef,
-       0x95, 0xc3, 0x4a, 0x69, 0x00, 0x6c, 0xc2, 0xb2,
-       0xe4, 0x31, 0x74, 0x46, 0xd0, 0xe0, 0x98, 0x77,
-       0x49, 0x8a, 0xd8, 0xe7, 0x0d, 0x97, 0xbb, 0x52,
-       0x84, 0x31, 0xfb, 0x08, 0x1b, 0xa3, 0xa3, 0x18,
-       0xf1, 0x58, 0x75, 0xb7, 0xe0, 0x00, 0x63, 0x0a,
-       0x9c, 0xed, 0x4e, 0x3f, 0x8e, 0x9a, 0xd0, 0x4a,
-       0xc2, 0x4e, 0xab, 0xff, 0xfc, 0x72, 0x24, 0x1a,
-       0xe8, 0xee, 0xbd, 0x29, 0xa4, 0x7e, 0xd3, 0xcd,
-       0x84, 0xe1, 0xb1, 0x54, 0xb2, 0xd3, 0x57, 0xd9,
-       0x5d, 0xfa, 0x6c, 0xc5, 0x96, 0xee, 0xcd, 0x70,
-       0xa5, 0xd2, 0x1d, 0xb8, 0x0d, 0x74, 0x3e, 0xbd,
-       0x37, 0x9b, 0x7f, 0xb7, 0x62, 0xe8, 0x94, 0xfc,
-       0x1e, 0x76, 0x66, 0x57, 0xab, 0x89, 0x3d, 0x63,
-       0xf0, 0x30, 0xac, 0x74, 0x39, 0xc7, 0x4a, 0xef,
-       0x71, 0x81, 0x9e, 0x7f, 0x81, 0x80, 0xbe, 0x2f,
-       0x38, 0x33, 0xec, 0xa9, 0x8d, 0xed, 0x33, 0xde,
-       0xa4, 0x9d, 0xe6, 0x5f, 0x72, 0xc9, 0x0c, 0x47,
-       0x7f, 0x81, 0x23, 0x5e, 0x35, 0x8e, 0x77, 0x16,
-       0xc5, 0x87, 0xd7, 0x24, 0xd9, 0xea, 0x1c, 0x13,
-       0xe9, 0x8a, 0x5e, 0xad, 0x76, 0x15, 0x86, 0xc5,
-       0x23, 0x48, 0x19, 0x29, 0xd3, 0x77, 0x60, 0xf6,
-       0xa7, 0x84, 0xd5, 0x33, 0xfd, 0xd3, 0xb5, 0xef,
-       0x4f, 0xe8, 0x5f, 0xf7, 0xd7, 0xee, 0xaa, 0x6d,
-       0xd3, 0x4b, 0x55, 0xbb, 0xd8, 0xe9, 0xfe, 0xec,
-       0x6b, 0x28, 0x32, 0x9d, 0xee, 0x2f, 0x6e, 0xf6,
-       0x81, 0x92, 0xa5, 0x72, 0x6d, 0x51, 0xb9, 0x1c,
-       0x9e, 0x9a, 0x38, 0xbe, 0x19, 0xfc, 0x2b, 0x00,
-       0x8a, 0x55, 0x84, 0x68, 0xb3, 0xca, 0xd9, 0x86,
-       0x6d, 0x93, 0xc8, 0xbf, 0x7f, 0x55, 0xe6, 0x95,
-       0xed, 0x1e, 0xbe, 0x27, 0xe0, 0x38, 0x6a, 0x8e,
-       0xbe, 0x8b, 0xb2, 0x42, 0xfd, 0xe2, 0x51, 0x3f,
-       0xbd, 0x9b, 0x31, 0x55, 0x1f, 0xd2, 0x49, 0xc6,
-       0x0c, 0xf6, 0x05, 0xc7, 0x48, 0x24, 0x6e, 0x97,
-       0x86, 0xba, 0x43, 0x83, 0xef, 0xf9, 0x28, 0xe9,
-       0x37, 0xab, 0xcf, 0x5f, 0x36, 0x32, 0x4d, 0x6d,
-       0xf4, 0xf8, 0x5d, 0xa2, 0x83, 0xbe, 0x86, 0xf9,
-       0x65, 0xfe, 0x61, 0xdb, 0xbe, 0xc7, 0xef, 0xce,
-       0x06, 0x13, 0xf6, 0xef, 0xaf, 0x71, 0xc7, 0x9d,
-       0x9b, 0x77, 0x45, 0x2d, 0x23, 0x9d, 0xf7, 0xca,
-       0xbe, 0xc5, 0xa5, 0xe5, 0xad, 0xef, 0xe5, 0x79,
-       0xeb, 0x7b, 0x6f, 0x96, 0x37, 0x96, 0x29, 0xe9,
-       0xcf, 0xcb, 0x3f, 0xc0, 0x4e, 0x70, 0x0a, 0x8f,
-       0x57, 0x92, 0xf3, 0xf4, 0x35, 0xee, 0xfd, 0x24,
-       0x7f, 0x5f, 0x30, 0x5b, 0x34, 0xe7, 0xd1, 0xd7,
-       0x35, 0xa6, 0x0c, 0x2f, 0x53, 0xe5, 0x29, 0x03,
-       0x5a, 0xd4, 0xe7, 0x6a, 0xa6, 0x94, 0x6b, 0x26,
-       0xdd, 0xeb, 0xd4, 0xd7, 0xb0, 0xa7, 0x51, 0xdf,
-       0x89, 0xd0, 0xd3, 0xb3, 0x1b, 0xf5, 0x33, 0xf1,
-       0x4b, 0xfe, 0x0d, 0xe9, 0x87, 0x95, 0x26, 0xa1,
-       0xc6, 0x3d, 0x11, 0xf8, 0xbf, 0x61, 0x1a, 0xda,
-       0x14, 0xa7, 0xa1, 0x52, 0xae, 0x21, 0xad, 0x0c,
-       0xfa, 0x5e, 0x2a, 0x83, 0xbe, 0xf7, 0xe6, 0x7a,
-       0xfa, 0x73, 0xca, 0x71, 0xa3, 0x9e, 0x9e, 0x1a,
-       0xa6, 0xa7, 0xf8, 0x92, 0x71, 0x3d, 0x79, 0x3f,
-       0xbe, 0x7a, 0x55, 0x2d, 0x63, 0x57, 0xfc, 0xb7,
-       0x26, 0xd2, 0x59, 0x69, 0xa9, 0x04, 0xbf, 0xa0,
-       0x37, 0x06, 0xb7, 0x4f, 0x3e, 0x4b, 0xfd, 0x27,
-       0xe5, 0x99, 0x95, 0x73, 0x69, 0xfe, 0x99, 0x6a,
-       0xb7, 0x15, 0x08, 0x50, 0xf6, 0x3b, 0x74, 0xa0,
-       0x4b, 0xa1, 0x0d, 0xaa, 0xf1, 0x7a, 0x12, 0x9e,
-       0x1b, 0xb3, 0x54, 0xe7, 0x83, 0x7e, 0xbc, 0xee,
-       0xd1, 0xb9, 0xc6, 0x2c, 0xd5, 0x67, 0xea, 0x36,
-       0xe2, 0x75, 0xb3, 0xee, 0xf4, 0x98, 0xa5, 0x06,
-       0xbd, 0xde, 0x89, 0xd7, 0x80, 0x3e, 0x9c, 0x72,
-       0x14, 0xbd, 0xd9, 0x7e, 0xcd, 0x96, 0xcd, 0x74,
-       0x56, 0xf1, 0xa9, 0xfe, 0x34, 0xe5, 0x22, 0xda,
-       0x3c, 0x6b, 0xab, 0xd3, 0xa2, 0xfa, 0xed, 0x94,
-       0xc8, 0xb9, 0x8a, 0x02, 0xf7, 0x51, 0xfa, 0xe7,
-       0x1b, 0xb3, 0xce, 0x06, 0x07, 0xba, 0x20, 0x5a,
-       0xc6, 0x4a, 0x90, 0x9a, 0x87, 0x39, 0xb3, 0x12,
-       0x95, 0x5d, 0x12, 0x80, 0x97, 0xf3, 0x68, 0x64,
-       0x3f, 0x95, 0x74, 0x5f, 0xca, 0xa6, 0x3f, 0xb7,
-       0x3c, 0x95, 0xa7, 0x4c, 0x6c, 0xa7, 0xc1, 0xe9,
-       0xc0, 0x50, 0x7e, 0x47, 0xd9, 0x0e, 0x8f, 0x99,
-       0x1e, 0xdf, 0x53, 0x8a, 0x39, 0x73, 0xd1, 0xad,
-       0x98, 0xbb, 0x78, 0xf9, 0xf3, 0xf2, 0xdf, 0xe4,
-       0xfa, 0xcb, 0x4b, 0x90, 0x9c, 0x48, 0x1e, 0x50,
-       0x5f, 0xc0, 0x7a, 0xf6, 0xb7, 0x71, 0xfe, 0x63,
-       0x1f, 0xfa, 0x0a, 0x9d, 0x04, 0xd3, 0x37, 0xd1,
-       0xb7, 0xc4, 0xdf, 0x88, 0x2c, 0xd5, 0x7b, 0x5c,
-       0x3d, 0x5d, 0xfa, 0xf0, 0x72, 0xa3, 0xb3, 0x58,
-       0xff, 0x48, 0x7e, 0x84, 0x68, 0x1f, 0x79, 0x09,
-       0x7e, 0xf3, 0x20, 0xe3, 0xd8, 0x4f, 0x1c, 0xfc,
-       0x89, 0x0b, 0x95, 0xa5, 0xc7, 0x8d, 0x9c, 0xba,
-       0x1a, 0x17, 0xe3, 0xdc, 0xef, 0x8d, 0x84, 0x91,
-       0xc6, 0xb8, 0x0f, 0x61, 0x5e, 0xb4, 0xe3, 0x69,
-       0xdb, 0xfa, 0x09, 0x32, 0x7f, 0xef, 0x62, 0xdb,
-       0x1b, 0x47, 0x70, 0xb6, 0xbf, 0x3e, 0xd6, 0x4b,
-       0x90, 0x47, 0xf5, 0x1f, 0x14, 0x3e, 0x68, 0x75,
-       0xd2, 0x73, 0x50, 0xa5, 0xd1, 0xe7, 0x52, 0xb2,
-       0x59, 0x38, 0xaa, 0x64, 0x20, 0xbc, 0x0f, 0xe1,
-       0x38, 0x84, 0xd3, 0x11, 0xa6, 0x22, 0x74, 0x20,
-       0xb4, 0x22, 0xcc, 0x46, 0x68, 0xac, 0x71, 0x89,
-       0xbd, 0x25, 0xec, 0xbb, 0x2a, 0x29, 0xfd, 0x00,
-       0x7e, 0x2c, 0x39, 0x54, 0x2b, 0x02, 0x8b, 0x05,
-       0xc5, 0xce, 0x52, 0x83, 0x62, 0x43, 0x38, 0x99,
-       0xce, 0xce, 0xe6, 0x39, 0xc8, 0xc7, 0x3c, 0xa3,
-       0xe9, 0x8d, 0x25, 0xf6, 0x3d, 0xab, 0x15, 0x4b,
-       0x1f, 0xf4, 0xb0, 0x32, 0x6a, 0xb6, 0x22, 0xb1,
-       0xf3, 0xb6, 0xc3, 0xea, 0x37, 0x03, 0x7b, 0xb9,
-       0xf7, 0x27, 0x8d, 0xad, 0xe6, 0xbd, 0x89, 0x7d,
-       0x89, 0x68, 0x83, 0x6a, 0xcb, 0xe3, 0xcb, 0x6d,
-       0xe5, 0xb8, 0x58, 0xc7, 0xdf, 0x73, 0xf8, 0xeb,
-       0x2f, 0x77, 0xe8, 0x5c, 0xf8, 0xdb, 0x88, 0xbf,
-       0xd3, 0xe5, 0x0e, 0xbd, 0x93, 0xbf, 0xdb, 0x46,
-       0xd2, 0xe8, 0x84, 0xd7, 0xf5, 0x13, 0x68, 0x1f,
-       0x9d, 0x96, 0xcf, 0xe7, 0xc9, 0x67, 0xad, 0xb3,
-       0x81, 0xef, 0x15, 0xfb, 0xd3, 0x39, 0xb0, 0x9d,
-       0x27, 0x1b, 0xd4, 0x77, 0xe8, 0x1c, 0x60, 0xf9,
-       0x3f, 0x75, 0x7a, 0xee, 0xe9, 0xb0, 0x6b, 0xbf,
-       0xfa, 0x5d, 0xf2, 0x6d, 0xeb, 0xc7, 0x2b, 0xa5,
-       0x4c, 0x67, 0xe3, 0x63, 0x75, 0x50, 0x6d, 0x83,
-       0xda, 0x93, 0xea, 0x60, 0x2b, 0x86, 0xf9, 0x29,
-       0xc5, 0xf0, 0xe2, 0x2b, 0xb6, 0x1f, 0x60, 0xd9,
-       0x5f, 0xc1, 0xb2, 0x23, 0xec, 0x7f, 0x05, 0xcb,
-       0xfe, 0x03, 0x2c, 0x3b, 0xc2, 0xd3, 0x3f, 0xc0,
-       0xb2, 0x97, 0xef, 0xc7, 0x72, 0xf3, 0x5e, 0x11,
-       0x56, 0xed, 0xa4, 0x36, 0x3e, 0x17, 0xb9, 0x94,
-       0x69, 0xed, 0x3f, 0x29, 0x17, 0xbe, 0xc7, 0xad,
-       0x3c, 0x22, 0xad, 0xf0, 0x38, 0x6d, 0xf4, 0xc4,
-       0xdf, 0x44, 0xdf, 0xfc, 0x8c, 0x51, 0xc5, 0xd1,
-       0x7b, 0xc1, 0x62, 0x03, 0x8c, 0xc3, 0x39, 0xfa,
-       0x1f, 0xce, 0xf3, 0xef, 0x81, 0xf2, 0xaf, 0x4f,
-       0x61, 0xac, 0xba, 0x67, 0x11, 0x67, 0x1a, 0x8f,
-       0xa8, 0x1c, 0x87, 0x50, 0xaa, 0x7e, 0x18, 0x4f,
-       0xf9, 0x10, 0x0f, 0x93, 0xa5, 0x43, 0x4e, 0x1c,
-       0x67, 0xff, 0xf0, 0xac, 0xc6, 0x79, 0xda, 0x45,
-       0x71, 0x7c, 0x4d, 0x5a, 0x83, 0x13, 0x48, 0xec,
-       0xeb, 0xa3, 0x46, 0xbf, 0x22, 0x80, 0x0d, 0xfa,
-       0xba, 0x69, 0xff, 0x39, 0xae, 0x33, 0x99, 0x36,
-       0xae, 0xba, 0xcc, 0x3a, 0x48, 0x5c, 0xf0, 0x06,
-       0x72, 0xcf, 0x24, 0xdb, 0xee, 0xb6, 0x96, 0xba,
-       0x8f, 0x76, 0x81, 0xe5, 0xc3, 0x8a, 0xa3, 0xfb,
-       0xec, 0xb8, 0x9a, 0xc7, 0xd9, 0xb6, 0xa9, 0x34,
-       0x8c, 0xa1, 0x29, 0xf4, 0x14, 0x32, 0x03, 0xfd,
-       0x64, 0xfa, 0x6d, 0x8a, 0x6b, 0xe7, 0xba, 0x36,
-       0xd3, 0xe6, 0xb5, 0xfe, 0xb0, 0x78, 0xa5, 0x66,
-       0xad, 0x6c, 0xf1, 0xd1, 0x17, 0x3a, 0xdf, 0x18,
-       0x5d, 0x1a, 0x8d, 0x62, 0x28, 0xb5, 0xfa, 0x0d,
-       0x9c, 0x21, 0x98, 0x08, 0x13, 0xcd, 0x1e, 0x03,
-       0xbd, 0x0b, 0x23, 0xd2, 0xee, 0xbb, 0xa4, 0x06,
-       0x7d, 0x00, 0x7a, 0x71, 0x9d, 0x6e, 0x8b, 0x88,
-       0xaf, 0x61, 0xee, 0x13, 0xe8, 0x0c, 0xf3, 0xfb,
-       0xb6, 0x1e, 0x86, 0x84, 0xdf, 0x7f, 0x00, 0xb0,
-       0xe5, 0xe9, 0x30, 0x8c, 0xf2, 0xb8, 0x40, 0xb7,
-       0xfe, 0x39, 0x80, 0xbb, 0x6c, 0x38, 0x49, 0xa6,
-       0x6f, 0x54, 0x34, 0xd2, 0x1c, 0x98, 0x66, 0xcf,
-       0xaa, 0x5d, 0x04, 0x58, 0x7d, 0x9e, 0xa1, 0x53,
-       0x43, 0x82, 0xcc, 0x5f, 0xd9, 0xb6, 0x14, 0x14,
-       0x83, 0xb2, 0x73, 0xec, 0xc2, 0xc3, 0xd1, 0x41,
-       0xf2, 0xe8, 0xb6, 0xbf, 0xfb, 0xdb, 0xb7, 0x0a,
-       0x2c, 0x29, 0xfb, 0xfd, 0x6e, 0x1c, 0x39, 0x4e,
-       0x73, 0x2f, 0x44, 0x63, 0x25, 0xed, 0x2c, 0xf2,
-       0xd1, 0xfb, 0x3c, 0xff, 0xe0, 0x5b, 0x92, 0x57,
-       0x6c, 0xa5, 0xaf, 0x6a, 0xbe, 0xc9, 0x76, 0xc7,
-       0x18, 0x78, 0x3c, 0xf9, 0x67, 0x1f, 0xbd, 0xa9,
-       0x78, 0xd3, 0xf8, 0xe8, 0xd5, 0x4c, 0x6f, 0x08,
-       0x0a, 0xe0, 0xb1, 0x41, 0x18, 0xb1, 0x6b, 0x15,
-       0xbd, 0x21, 0x29, 0x3b, 0xf8, 0x7b, 0x93, 0x82,
-       0xde, 0xeb, 0xa2, 0x37, 0xa5, 0x64, 0x3b, 0x5a,
-       0x09, 0xdb, 0xe9, 0x50, 0xdd, 0xfa, 0x6e, 0x24,
-       0x30, 0x33, 0xf3, 0x78, 0x26, 0xfb, 0xfe, 0xb3,
-       0xe8, 0xa2, 0x15, 0x20, 0x7d, 0xd1, 0x56, 0x6e,
-       0x65, 0xf3, 0x96, 0x11, 0x3c, 0x9d, 0x67, 0x0b,
-       0xfd, 0xe3, 0xfc, 0xc1, 0x11, 0x6b, 0xd0, 0x42,
-       0x74, 0x6f, 0x2b, 0x2f, 0x05, 0xa2, 0xb4, 0xd3,
-       0x48, 0x6e, 0x55, 0x65, 0xb3, 0xd1, 0x5f, 0x7b,
-       0x87, 0x85, 0x76, 0x86, 0xde, 0xac, 0x24, 0xb8,
-       0xba, 0xf7, 0x71, 0xf9, 0x81, 0x68, 0x7c, 0x3a,
-       0x2a, 0x99, 0x9a, 0x17, 0x96, 0x6f, 0x78, 0xe9,
-       0x84, 0x7f, 0x13, 0xfe, 0x8d, 0x4a, 0x47, 0x73,
-       0x30, 0x79, 0xf5, 0xf5, 0x39, 0xf8, 0x98, 0xdc,
-       0x65, 0xea, 0x7b, 0x7b, 0xf2, 0x6a, 0xed, 0xad,
-       0x4f, 0xb9, 0xad, 0xa4, 0x0f, 0x46, 0x84, 0xa2,
-       0x01, 0x8b, 0x7f, 0x9d, 0xcf, 0xbe, 0x00, 0xd3,
-       0x2b, 0x45, 0x41, 0xa8, 0xe9, 0xf6, 0xd8, 0xfd,
-       0x6b, 0x5f, 0x79, 0x53, 0x31, 0xd2, 0xd9, 0xbb,
-       0x3b, 0xbb, 0x60, 0x84, 0x52, 0xcd, 0x73, 0x22,
-       0x3f, 0x23, 0xb7, 0x52, 0x9d, 0x7b, 0x3d, 0x07,
-       0x30, 0xff, 0x77, 0xf7, 0x53, 0x3d, 0xe1, 0x23,
-       0x79, 0x9c, 0xd8, 0x33, 0x14, 0x17, 0xd3, 0x41,
-       0x14, 0xe3, 0x0e, 0x2b, 0xa9, 0x37, 0xd3, 0x81,
-       0xe7, 0xde, 0x1b, 0xcb, 0x19, 0x09, 0xe3, 0xaa,
-       0x0d, 0x57, 0x61, 0x1b, 0x70, 0x05, 0x7b, 0xad,
-       0xcf, 0xef, 0xc2, 0xb9, 0x06, 0xd4, 0xb8, 0xe5,
-       0x4b, 0xb8, 0xa6, 0x2d, 0x46, 0xea, 0x16, 0x8d,
-       0x5b, 0x67, 0x88, 0x71, 0xa7, 0x21, 0x3d, 0x0b,
-       0xb9, 0x9d, 0xf1, 0xdc, 0x1b, 0xda, 0x6e, 0xc2,
-       0x99, 0x82, 0x5c, 0x9b, 0xe3, 0xb9, 0xae, 0xf5,
-       0xdd, 0x84, 0x2b, 0x59, 0x82, 0xcf, 0xce, 0x0e,
-       0x71, 0x0d, 0xe7, 0x88, 0xff, 0xe2, 0x6a, 0x99,
-       0xcf, 0x1b, 0xf1, 0xee, 0x73, 0x78, 0xf9, 0x5b,
-       0x39, 0x98, 0x8a, 0xed, 0x37, 0xf7, 0x95, 0xf9,
-       0xdc, 0xf7, 0xd3, 0x7b, 0x47, 0xa5, 0x4b, 0xc7,
-       0xd2, 0x7b, 0x58, 0xa6, 0xd3, 0xbc, 0xce, 0xab,
-       0xa3, 0xc2, 0x4f, 0xe9, 0x5f, 0xfe, 0x4f, 0x49,
-       0x0f, 0xf4, 0x46, 0xae, 0x2f, 0xe3, 0x75, 0xb6,
-       0x0f, 0x72, 0x21, 0x71, 0x17, 0x7b, 0x23, 0x59,
-       0xb0, 0x01, 0x35, 0x27, 0x24, 0x78, 0xf9, 0xbb,
-       0x79, 0x99, 0x98, 0xee, 0x27, 0xef, 0xc2, 0xf4,
-       0x2e, 0x1c, 0xd4, 0xe9, 0xab, 0xe2, 0xec, 0x2b,
-       0xe1, 0x2c, 0x66, 0x1a, 0xfb, 0xea, 0xf1, 0xb3,
-       0xd3, 0xbb, 0x9e, 0x02, 0x78, 0x96, 0x5a, 0xd3,
-       0x57, 0x2c, 0x9b, 0xa6, 0x77, 0x3d, 0x06, 0x44,
-       0x2b, 0x7d, 0x1c, 0xd6, 0xa0, 0xdd, 0xd9, 0xd4,
-       0x37, 0x99, 0x00, 0x8e, 0x73, 0x0e, 0x25, 0x0d,
-       0x67, 0x30, 0x06, 0x3a, 0xdf, 0x4e, 0xb6, 0xe6,
-       0xb3, 0xb7, 0xac, 0x7d, 0x5e, 0x11, 0xe0, 0x35,
-       0x1c, 0x61, 0x9b, 0xf9, 0xfb, 0x3c, 0xba, 0x8d,
-       0x74, 0x96, 0xac, 0xc1, 0xcc, 0x6a, 0x31, 0x13,
-       0xb5, 0xb1, 0x91, 0x56, 0x35, 0xbe, 0xca, 0x74,
-       0x38, 0x8a, 0x2b, 0xc7, 0x02, 0x98, 0x75, 0x21,
-       0x0d, 0x7e, 0x14, 0x69, 0x4f, 0x7f, 0x75, 0x5f,
-       0xeb, 0x78, 0x09, 0x06, 0x9f, 0x4b, 0x2f, 0x46,
-       0x29, 0xd0, 0xb3, 0x97, 0x6a, 0xaf, 0x98, 0x10,
-       0x43, 0x28, 0xb8, 0xe9, 0xde, 0x46, 0xe5, 0xa9,
-       0x24, 0x83, 0x9a, 0xab, 0x9d, 0x95, 0x23, 0x53,
-       0xae, 0xb6, 0xae, 0x82, 0x11, 0x54, 0xe7, 0xe5,
-       0xe5, 0x12, 0x18, 0x5f, 0x14, 0xad, 0x98, 0x93,
-       0xa0, 0x96, 0x91, 0xcd, 0x26, 0x7c, 0x33, 0xe5,
-       0x6c, 0x75, 0xbd, 0x93, 0xa1, 0x7d, 0xf9, 0x7c,
-       0xf8, 0x97, 0x48, 0xfd, 0xd8, 0xeb, 0xf4, 0x4b,
-       0xe9, 0x0e, 0x24, 0xae, 0x40, 0xea, 0xd1, 0xae,
-       0x8e, 0x62, 0x5e, 0x63, 0xd5, 0xb2, 0xf7, 0x4a,
-       0xa0, 0x7e, 0x0d, 0xfa, 0xd9, 0xe9, 0x24, 0x75,
-       0x1a, 0x6a, 0x46, 0x6d, 0xb9, 0x47, 0xa2, 0x31,
-       0x1f, 0x8b, 0xfa, 0xe4, 0xfc, 0xe8, 0x30, 0xc3,
-       0x98, 0xa6, 0x5e, 0x6f, 0x83, 0x47, 0xa4, 0x25,
-       0xba, 0x8d, 0x52, 0x9d, 0x8e, 0x7d, 0xbd, 0x5c,
-       0xb6, 0xc7, 0x7d, 0x9b, 0x62, 0x3c, 0xff, 0x36,
-       0x85, 0x8e, 0x4a, 0x32, 0x83, 0x8f, 0x8f, 0xa8,
-       0xd9, 0xa7, 0xaf, 0x97, 0x85, 0x72, 0xc6, 0x92,
-       0x3c, 0x29, 0x15, 0xe5, 0xd8, 0x10, 0xb3, 0xea,
-       0x5e, 0x1d, 0x4a, 0x81, 0x7a, 0xd4, 0x73, 0x9b,
-       0x09, 0x24, 0xc5, 0xbe, 0xa3, 0xab, 0x0f, 0x8c,
-       0x49, 0xc9, 0x01, 0xd3, 0x4e, 0xfe, 0x7e, 0xcf,
-       0xa1, 0xe8, 0xe5, 0xca, 0x53, 0x2e, 0xc3, 0x30,
-       0xde, 0xdc, 0x38, 0xde, 0x86, 0x2f, 0xe6, 0x75,
-       0x16, 0xeb, 0x6e, 0x8f, 0x71, 0xd3, 0x8c, 0xeb,
-       0x9e, 0x9b, 0xf1, 0x9b, 0x37, 0x92, 0x8d, 0x46,
-       0x83, 0xe6, 0x5e, 0x84, 0x4f, 0xb3, 0x1d, 0x30,
-       0xa7, 0x79, 0x2d, 0x50, 0xd3, 0x68, 0x15, 0xb6,
-       0xbd, 0x7c, 0xd6, 0xe8, 0xcb, 0xae, 0x3e, 0x11,
-       0x30, 0xae, 0xd0, 0x33, 0xcd, 0x40, 0xd4, 0x83,
-       0x75, 0xc2, 0xbe, 0x47, 0xfa, 0x8d, 0x16, 0x32,
-       0xad, 0x11, 0x9e, 0x1d, 0x84, 0xd0, 0x84, 0xa3,
-       0x6b, 0xcd, 0xa3, 0x21, 0x41, 0xd1, 0xfb, 0xd7,
-       0xb2, 0x58, 0x3b, 0x8b, 0x49, 0x99, 0x77, 0x38,
-       0xda, 0xc7, 0x70, 0xb3, 0x6f, 0xed, 0xc2, 0x13,
-       0x6c, 0x17, 0xcd, 0x6e, 0x5c, 0x39, 0xf3, 0x6f,
-       0xc2, 0x46, 0xe2, 0xf5, 0x96, 0x07, 0x47, 0xdd,
-       0x4c, 0xeb, 0xd3, 0xe5, 0x69, 0xba, 0x8d, 0xfc,
-       0x64, 0x27, 0xcf, 0xd7, 0x6d, 0x03, 0x58, 0x42,
-       0x1c, 0x1d, 0xaf, 0x1d, 0x42, 0x7b, 0x35, 0x52,
-       0xc9, 0x14, 0x0b, 0x95, 0xa3, 0x16, 0x63, 0xc4,
-       0x0b, 0xdc, 0x2a, 0x88, 0x8b, 0xb5, 0xca, 0x74,
-       0x5d, 0x6f, 0xcc, 0xdb, 0xbb, 0xd4, 0xd6, 0x60,
-       0x12, 0x95, 0x69, 0x3c, 0x27, 0x2a, 0xd3, 0xb5,
-       0x35, 0xac, 0x3d, 0xa6, 0xf3, 0x1c, 0xb8, 0x2d,
-       0x21, 0xb5, 0x59, 0x1a, 0xc7, 0x53, 0x70, 0x99,
-       0xbd, 0xae, 0x7c, 0xec, 0x8d, 0x30, 0x40, 0x12,
-       0xf5, 0x7c, 0xb5, 0x01, 0x1e, 0x23, 0xf2, 0xb9,
-       0xa6, 0x26, 0x71, 0x8e, 0x3c, 0xc6, 0x7d, 0xd4,
-       0x9d, 0x97, 0x6b, 0x1b, 0x48, 0x7f, 0xa8, 0x10,
-       0xce, 0xb8, 0xce, 0xb8, 0x77, 0xba, 0x96, 0x5b,
-       0xa9, 0xbc, 0x9b, 0x5c, 0x4e, 0x5d, 0xe8, 0x9a,
-       0x68, 0x43, 0x2d, 0xeb, 0x36, 0xba, 0x43, 0x7a,
-       0xd1, 0x44, 0xf7, 0x8b, 0xab, 0x0f, 0xd0, 0x59,
-       0xc5, 0x53, 0x93, 0xae, 0xcb, 0xe7, 0x51, 0xc0,
-       0xf4, 0x07, 0x69, 0xb7, 0xa6, 0x09, 0xd3, 0xea,
-       0x45, 0x23, 0xa6, 0xc2, 0x51, 0xfe, 0x9a, 0xde,
-       0x67, 0xa4, 0xb7, 0x84, 0xaf, 0x65, 0x56, 0x9e,
-       0x02, 0xb6, 0xc2, 0x58, 0x6b, 0x5b, 0x63, 0x9c,
-       0xde, 0xe5, 0x02, 0xc8, 0x40, 0xef, 0xb2, 0x27,
-       0x93, 0x8d, 0x66, 0x53, 0x66, 0x83, 0xe0, 0x2c,
-       0xde, 0x4a, 0xdf, 0x59, 0xd6, 0xc3, 0x33, 0xd3,
-       0x5d, 0x90, 0x41, 0xbf, 0x38, 0xab, 0x6d, 0x24,
-       0x58, 0x6f, 0x47, 0x8f, 0x31, 0x3e, 0x82, 0x3c,
-       0xca, 0x05, 0x55, 0x42, 0xaa, 0x62, 0x9d, 0xf7,
-       0x4e, 0x74, 0x67, 0x3e, 0x3b, 0x85, 0x81, 0xbd,
-       0x3f, 0xb9, 0x96, 0x79, 0xb4, 0xd3, 0x39, 0xc5,
-       0xf3, 0xf1, 0x4f, 0xa8, 0xa4, 0x73, 0x61, 0x7c,
-       0x19, 0xf8, 0x73, 0xb0, 0x50, 0x26, 0xfe, 0xb2,
-       0x56, 0x5a, 0x56, 0x40, 0xfa, 0xec, 0x92, 0x73,
-       0x05, 0x90, 0x31, 0xfb, 0x87, 0xf4, 0x2e, 0xfc,
-       0x51, 0xeb, 0xe2, 0xd2, 0xc7, 0xe5, 0xcb, 0x56,
-       0x7f, 0xe9, 0xe3, 0xca, 0x45, 0x5b, 0x16, 0xe8,
-       0x53, 0xb2, 0xc0, 0x14, 0x49, 0xdc, 0x9f, 0xd8,
-       0x8b, 0xa6, 0xb1, 0x1b, 0xfd, 0x40, 0xd9, 0x79,
-       0xe3, 0x0c, 0xf1, 0x98, 0xff, 0xd1, 0xb2, 0xf3,
-       0xe0, 0x10, 0xc6, 0xa6, 0x8f, 0x8d, 0x7c, 0x6b,
-       0xff, 0xb7, 0x7a, 0xc3, 0xe1, 0xb5, 0xd9, 0x30,
-       0xd5, 0x52, 0x76, 0x3e, 0xda, 0x1b, 0x80, 0xd5,
-       0x49, 0xe9, 0x63, 0x7f, 0x10, 0xa6, 0x3d, 0x66,
-       0x19, 0x0f, 0x45, 0xbe, 0xd5, 0xb3, 0x1e, 0x57,
-       0x73, 0xd7, 0xf1, 0x05, 0x60, 0x5a, 0x31, 0xcc,
-       0x24, 0xae, 0xf8, 0x1f, 0x9d, 0xf2, 0xa7, 0xa6,
-       0xf0, 0xb1, 0xbe, 0x9d, 0xa1, 0x14, 0x72, 0xef,
-       0xa2, 0x98, 0x6b, 0x18, 0x14, 0x33, 0x57, 0x3f,
-       0x92, 0x9e, 0xa5, 0x07, 0x21, 0x26, 0xcd, 0x11,
-       0xa1, 0x54, 0x2c, 0x36, 0x83, 0x3f, 0x97, 0xf0,
-       0xcd, 0x14, 0x8d, 0xb8, 0xae, 0xcb, 0x43, 0x9b,
-       0x8c, 0xd2, 0x6e, 0x4c, 0x56, 0x57, 0x07, 0xc5,
-       0xb3, 0x50, 0x16, 0xc9, 0x71, 0x78, 0x59, 0x2c,
-       0x9d, 0x47, 0x50, 0xac, 0xe9, 0x7f, 0xb0, 0x31,
-       0x5e, 0xff, 0x27, 0xae, 0xd3, 0x7f, 0x4c, 0xdb,
-       0x57, 0x62, 0xfc, 0x05, 0x4c, 0xbb, 0xfd, 0xb3,
-       0x86, 0xfb, 0xb1, 0x7c, 0x18, 0xe0, 0x72, 0xb2,
-       0x98, 0xd6, 0xb3, 0x13, 0x4e, 0xae, 0x67, 0xde,
-       0xaf, 0x54, 0x61, 0xcf, 0x05, 0x7c, 0x65, 0xb2,
-       0x2d, 0xaf, 0xd8, 0x30, 0x33, 0xf3, 0x20, 0xff,
-       0x47, 0xab, 0x5f, 0xce, 0x3f, 0xeb, 0xd7, 0x09,
-       0x82, 0x64, 0x65, 0x35, 0x28, 0xab, 0x3c, 0x35,
-       0x0a, 0xcb, 0xc6, 0xde, 0x05, 0x74, 0x63, 0x7b,
-       0x92, 0x5f, 0xf5, 0xac, 0xb4, 0x48, 0x99, 0xb3,
-       0x7e, 0x6d, 0x74, 0x99, 0x56, 0x41, 0x94, 0x70,
-       0x5e, 0x67, 0xac, 0xe9, 0x79, 0xae, 0x2b, 0xfe,
-       0x15, 0x6a, 0xdf, 0xcc, 0xaa, 0x4e, 0x61, 0x76,
-       0x5d, 0xb7, 0x30, 0x58, 0xfa, 0x78, 0xe9, 0xe3,
-       0xcc, 0xbf, 0xbb, 0xa4, 0x80, 0xfb, 0xd7, 0x60,
-       0xa6, 0xb7, 0x21, 0xe1, 0x39, 0xa9, 0x51, 0x2d,
-       0x4d, 0x76, 0x05, 0x1b, 0xc1, 0xd5, 0x32, 0x55,
-       0x06, 0xe8, 0x4d, 0xd9, 0x09, 0x8e, 0x08, 0xff,
-       0x87, 0x76, 0x74, 0x85, 0xc7, 0x3b, 0xd8, 0x9b,
-       0x97, 0xd5, 0xdd, 0x6b, 0x1e, 0x11, 0xc6, 0x65,
-       0xc2, 0x19, 0xba, 0x07, 0xfe, 0x98, 0xbb, 0x4f,
-       0x37, 0x28, 0x18, 0xa4, 0xd5, 0xee, 0xbe, 0x6b,
-       0x40, 0x67, 0x99, 0xa3, 0x74, 0x57, 0x5e, 0xb1,
-       0x0e, 0xa4, 0x5a, 0x0c, 0x15, 0xf1, 0xb5, 0x91,
-       0x13, 0x18, 0xb7, 0x05, 0xf9, 0xfc, 0x68, 0xed,
-       0xd6, 0xaa, 0xce, 0xc8, 0x37, 0x33, 0xe0, 0xc7,
-       0xeb, 0xd2, 0xf5, 0xc7, 0xd6, 0x9d, 0x79, 0xdc,
-       0xbc, 0x0f, 0x26, 0xec, 0x5f, 0x17, 0x5e, 0x6b,
-       0x76, 0xd0, 0x3d, 0x60, 0xc5, 0x68, 0x0e, 0xc3,
-       0x04, 0x21, 0x42, 0x77, 0x4a, 0x6a, 0xdc, 0x01,
-       0xc8, 0xb0, 0xff, 0x90, 0xde, 0x6a, 0x1e, 0xc0,
-       0x14, 0x13, 0xae, 0xa7, 0x65, 0x4c, 0x88, 0x7c,
-       0xf3, 0xcb, 0xc8, 0x4a, 0xb1, 0xb1, 0xdd, 0xcd,
-       0x56, 0x9c, 0x25, 0x9b, 0xf0, 0xba, 0x0f, 0x12,
-       0xb1, 0x17, 0xae, 0x85, 0x44, 0xdb, 0x5a, 0xb6,
-       0x5b, 0xae, 0x0d, 0x7f, 0x47, 0x44, 0xd0, 0x65,
-       0xe3, 0x2f, 0x07, 0x7f, 0x61, 0xc4, 0x4d, 0xf8,
-       0xcb, 0x46, 0x3f, 0xd3, 0xfd, 0x61, 0x45, 0xc5,
-       0x1f, 0x6c, 0xa9, 0x67, 0x2b, 0x44, 0x93, 0xd0,
-       0x28, 0x79, 0xf8, 0x1b, 0xd6, 0x95, 0xa7, 0x46,
-       0x1b, 0x3e, 0xac, 0x98, 0xfa, 0x5d, 0x1b, 0xcc,
-       0xfd, 0x83, 0x0d, 0xce, 0x56, 0x30, 0x8f, 0x34,
-       0x9c, 0x73, 0xf5, 0xe7, 0x71, 0x4e, 0x85, 0xde,
-       0xef, 0x83, 0xd1, 0xb7, 0x0c, 0x6c, 0x72, 0x7a,
-       0xec, 0x2d, 0xe6, 0x52, 0x09, 0xae, 0xf8, 0xf8,
-       0x7d, 0x7f, 0x9f, 0x73, 0x2a, 0x04, 0xd0, 0x23,
-       0xc2, 0x80, 0x30, 0x41, 0xcc, 0xb6, 0x2e, 0xc3,
-       0x79, 0x33, 0xe7, 0x64, 0x6f, 0x39, 0xd3, 0x6c,
-       0xe9, 0x8a, 0x90, 0x3f, 0xc8, 0x31, 0x95, 0xb3,
-       0x17, 0x39, 0xf5, 0xf4, 0x56, 0xf5, 0xef, 0xc7,
-       0x0a, 0xa4, 0x23, 0xa0, 0x37, 0xda, 0x6e, 0x92,
-       0x8b, 0x07, 0x39, 0xce, 0x5e, 0x97, 0xcb, 0x66,
-       0x4c, 0x9b, 0xa5, 0xe6, 0x22, 0xc4, 0x72, 0xb1,
-       0x23, 0xe7, 0x6b, 0xc3, 0x72, 0x59, 0x1a, 0xcb,
-       0xc3, 0x45, 0x79, 0x20, 0xdc, 0x5a, 0xd5, 0xc9,
-       0xe4, 0x0b, 0x31, 0xf9, 0x38, 0x62, 0xff, 0xfe,
-       0xb1, 0x61, 0xf2, 0x0b, 0x3e, 0x57, 0xfa, 0x92,
-       0x61, 0xd2, 0xad, 0x9a, 0xf4, 0xab, 0x4f, 0xb2,
-       0x77, 0x19, 0xc2, 0x74, 0xbe, 0x30, 0xac, 0x61,
-       0xf2, 0x0b, 0x63, 0xf2, 0xd1, 0xda, 0x30, 0x65,
-       0xba, 0x96, 0x83, 0xb6, 0x92, 0x92, 0xdb, 0x02,
-       0xea, 0xb7, 0x33, 0xf8, 0xac, 0x93, 0x7d, 0x75,
-       0xb9, 0x4e, 0xcd, 0xb5, 0x20, 0x96, 0x2b, 0xce,
-       0x44, 0x2e, 0x7f, 0xa4, 0xe5, 0xfa, 0x85, 0x69,
-       0xc7, 0x61, 0xdb, 0xaf, 0xbf, 0x59, 0x6c, 0x40,
-       0x27, 0xb6, 0x0d, 0x9b, 0x0b, 0x6c, 0xa4, 0x11,
-       0x00, 0x4b, 0x6d, 0x61, 0xf7, 0x8b, 0x68, 0xb6,
-       0x45, 0xbb, 0xd1, 0x1f, 0xe3, 0x63, 0xda, 0x1f,
-       0x2e, 0x63, 0x78, 0x25, 0xc2, 0x0b, 0xb1, 0xd8,
-       0x64, 0x5d, 0x2f, 0x7f, 0xde, 0xe3, 0xf3, 0x06,
-       0xa2, 0x62, 0xba, 0xae, 0xf7, 0x73, 0x72, 0x31,
-       0xeb, 0xd0, 0x73, 0x8a, 0xfa, 0x80, 0x8e, 0xde,
-       0xe2, 0x60, 0x36, 0xfa, 0x22, 0xfe, 0xde, 0xc6,
-       0xdf, 0x65, 0xfc, 0x5d, 0xc2, 0x5f, 0xbf, 0x6a,
-       0xa3, 0x39, 0xc3, 0x2c, 0xcf, 0x8c, 0x96, 0x87,
-       0x7a, 0x63, 0xb6, 0x77, 0xe5, 0x66, 0x56, 0x7a,
-       0x3a, 0x2c, 0x15, 0x92, 0x65, 0x7c, 0x58, 0xe1,
-       0x66, 0x29, 0x0a, 0x74, 0x79, 0x77, 0xd3, 0x09,
-       0xfa, 0x09, 0x47, 0x7d, 0x61, 0xc5, 0x8c, 0x65,
-       0x1b, 0xa9, 0xce, 0x7f, 0x13, 0xe9, 0x8e, 0xd3,
-       0xf0, 0xb4, 0x02, 0x9d, 0x25, 0xb2, 0x4d, 0xff,
-       0x7c, 0x68, 0xd4, 0x8f, 0x8e, 0x2b, 0x34, 0xf2,
-       0x0f, 0x70, 0xdc, 0xb7, 0x45, 0x1e, 0x9c, 0x38,
-       0x9b, 0x56, 0x5a, 0x49, 0x46, 0xfe, 0x2d, 0xf8,
-       0x9e, 0xef, 0x83, 0xb9, 0xd5, 0x46, 0xf9, 0x70,
-       0xe9, 0x86, 0x05, 0xc3, 0xa5, 0x03, 0x1f, 0xc3,
-       0x41, 0x7a, 0xf1, 0x7a, 0x4e, 0x63, 0xc1, 0x8d,
-       0x9c, 0xf4, 0x4f, 0x7b, 0x37, 0x8f, 0x8d, 0xaa,
-       0x62, 0xfa, 0x68, 0xc5, 0x98, 0xee, 0x16, 0xaf,
-       0xf2, 0x37, 0xc3, 0xe9, 0xd4, 0x7b, 0x5d, 0x16,
-       0x5a, 0x8c, 0x5e, 0x2a, 0xe4, 0x67, 0xe7, 0xb3,
-       0x13, 0x24, 0x28, 0x46, 0xc7, 0xe6, 0xc6, 0x14,
-       0x33, 0x4e, 0xe3, 0x0d, 0x68, 0xe7, 0xda, 0x1b,
-       0xe9, 0x0e, 0x39, 0x5f, 0x89, 0x74, 0x01, 0x8f,
-       0xa5, 0xb3, 0x26, 0xf4, 0x2f, 0x5a, 0x37, 0xfa,
-       0x4b, 0x6b, 0x66, 0x2b, 0xc9, 0xfe, 0xf5, 0xec,
-       0x19, 0x8a, 0x0d, 0xed, 0xee, 0x25, 0xf1, 0xfd,
-       0x6c, 0x07, 0x6c, 0x14, 0x1c, 0x30, 0x0e, 0xb1,
-       0x67, 0x43, 0xd1, 0x9e, 0x75, 0x74, 0xb2, 0x0e,
-       0x72, 0x77, 0x59, 0x37, 0xd2, 0xf7, 0x17, 0xe9,
-       0x44, 0x60, 0x8c, 0x8d, 0x9c, 0xee, 0xc6, 0x19,
-       0x32, 0x3a, 0x49, 0x39, 0x50, 0x76, 0x0e, 0x16,
-       0xfc, 0x70, 0x90, 0xbc, 0x66, 0x6b, 0x6b, 0xfa,
-       0x86, 0x74, 0x9f, 0xe7, 0xa9, 0xb2, 0x3e, 0xc8,
-       0x98, 0x75, 0x0e, 0xd2, 0x2a, 0xce, 0x41, 0xa1,
-       0xe7, 0x3b, 0x21, 0x48, 0x1d, 0x9b, 0xb6, 0xdf,
-       0xbe, 0x5f, 0xb4, 0xd8, 0xc6, 0xda, 0x23, 0x12,
-       0x9c, 0x1e, 0x9f, 0x46, 0x27, 0x4d, 0x5c, 0x46,
-       0x29, 0xcf, 0x47, 0x0e, 0xd2, 0x09, 0x0e, 0x19,
-       0x0e, 0xd8, 0xe1, 0xf7, 0x1c, 0x38, 0xb8, 0x39,
-       0x3c, 0xc9, 0x03, 0xe6, 0x7c, 0x37, 0xd8, 0x26,
-       0x75, 0xf1, 0x2f, 0x1c, 0x50, 0x69, 0x7b, 0x50,
-       0x5b, 0xba, 0x6b, 0x93, 0xaa, 0x41, 0xad, 0x2b,
-       0x7d, 0x33, 0x5c, 0x86, 0xa8, 0xac, 0x9e, 0x8c,
-       0xf4, 0x05, 0x77, 0x66, 0xd8, 0xfd, 0x2f, 0xd4,
-       0x00, 0xae, 0x7e, 0xd8, 0x77, 0xcb, 0x7c, 0x75,
-       0x99, 0xab, 0xa3, 0x47, 0xe2, 0xe6, 0x14, 0xd5,
-       0x6c, 0x4e, 0x01, 0xb0, 0x95, 0xee, 0x9d, 0x7c,
-       0x77, 0x97, 0x2f, 0x1f, 0x60, 0x59, 0xdf, 0xb9,
-       0xa4, 0xfd, 0xc5, 0x60, 0x5b, 0x57, 0x0c, 0xcf,
-       0x31, 0xea, 0xce, 0x5b, 0xd7, 0x02, 0xb0, 0xd0,
-       0xee, 0x5b, 0xf7, 0xc2, 0x05, 0x9a, 0x6d, 0xc2,
-       0x7b, 0xb2, 0xcc, 0x53, 0xd8, 0x30, 0x05, 0xf3,
-       0xb8, 0x0b, 0xe8, 0x4d, 0x29, 0x46, 0x7b, 0xbe,
-       0xe4, 0x77, 0xc8, 0x8f, 0x6b, 0xfe, 0xbc, 0xd1,
-       0xa7, 0x17, 0x39, 0xf7, 0xd1, 0x4c, 0x89, 0xde,
-       0x88, 0xca, 0xdb, 0x01, 0xfa, 0x7c, 0xf6, 0x96,
-       0x14, 0x5e, 0xad, 0x60, 0x0c, 0x82, 0xd3, 0x01,
-       0x2b, 0x30, 0xad, 0x59, 0xd1, 0xa7, 0x00, 0xd6,
-       0xd9, 0x74, 0x9d, 0x44, 0x23, 0xeb, 0x17, 0xd1,
-       0xca, 0x53, 0x23, 0x4c, 0x7c, 0x9e, 0xef, 0x7b,
-       0x15, 0xe3, 0x9f, 0x93, 0xed, 0x8c, 0x6f, 0x0f,
-       0x2b, 0xeb, 0xc0, 0x50, 0x1a, 0x71, 0x9a, 0xb0,
-       0xfa, 0xda, 0x65, 0x9b, 0x6d, 0xe9, 0x55, 0xfe,
-       0x0d, 0x05, 0xd9, 0x1a, 0x17, 0x37, 0xde, 0xf5,
-       0x31, 0xdd, 0x3b, 0x1a, 0xa2, 0xd8, 0x6c, 0x7a,
-       0x00, 0x43, 0xb8, 0x18, 0xba, 0x6c, 0xe1, 0xf2,
-       0x53, 0x43, 0xf7, 0xe2, 0xd4, 0x3c, 0xf2, 0x6e,
-       0xd0, 0x51, 0x88, 0xe7, 0x4a, 0x69, 0x97, 0xea,
-       0xc5, 0xbe, 0xeb, 0x6b, 0x2f, 0x56, 0xde, 0x90,
-       0xc2, 0x83, 0xe5, 0x69, 0xc4, 0xf2, 0x5c, 0xfc,
-       0xf3, 0xcb, 0x43, 0x3b, 0xed, 0xa9, 0x44, 0x54,
-       0x7b, 0x5e, 0xb2, 0x1b, 0x5b, 0xd2, 0x37, 0x0f,
-       0xed, 0xb2, 0x2f, 0x73, 0xf5, 0x67, 0x83, 0x05,
-       0x6a, 0xdb, 0x09, 0xb0, 0xec, 0xf2, 0x50, 0xdb,
-       0x15, 0x4c, 0x06, 0xfd, 0x81, 0x73, 0x38, 0x32,
-       0x78, 0x90, 0x2f, 0x12, 0xde, 0xdf, 0x33, 0x0f,
-       0x67, 0x79, 0x7b, 0x18, 0xef, 0xcb, 0xb7, 0xd2,
-       0xdb, 0xd2, 0x5e, 0x16, 0xee, 0xa1, 0xb0, 0xc7,
-       0xe5, 0x75, 0x85, 0x91, 0x17, 0x67, 0x3a, 0xa3,
-       0xd6, 0x81, 0xd7, 0xd5, 0xd3, 0x02, 0x46, 0x3a,
-       0x09, 0xc8, 0x0f, 0x8c, 0xe7, 0x25, 0xe2, 0x29,
-       0x50, 0x6d, 0x41, 0x0d, 0xbd, 0x88, 0xb6, 0xa0,
-       0x53, 0xc3, 0x64, 0x17, 0x02, 0x7d, 0x23, 0xf9,
-       0xda, 0xe2, 0xeb, 0xf4, 0x52, 0x3e, 0xcc, 0x22,
-       0x46, 0x39, 0xdf, 0xfd, 0xe2, 0x7f, 0x68, 0x2b,
-       0xef, 0x7f, 0xb1, 0x15, 0x7c, 0x8e, 0x1e, 0xae,
-       0x64, 0xae, 0x1e, 0xbc, 0xfc, 0xc5, 0x7a, 0x08,
-       0xef, 0x67, 0x9a, 0x38, 0xc2, 0xf4, 0x70, 0xf0,
-       0xcf, 0xd2, 0xc3, 0x96, 0x3f, 0x43, 0x0f, 0x4e,
-       0x21, 0xae, 0x55, 0x97, 0x5d, 0xe6, 0xd6, 0xc1,
-       0x4e, 0x85, 0xe8, 0x1b, 0xae, 0x8b, 0xbc, 0x2d,
-       0x5f, 0xfc, 0x8f, 0x74, 0x81, 0xab, 0x03, 0xf3,
-       0x75, 0xfa, 0xb0, 0xe0, 0x35, 0x51, 0x3e, 0x3f,
-       0x5c, 0x2b, 0x81, 0xfe, 0x1b, 0xb4, 0x82, 0x75,
-       0xd5, 0xe9, 0x99, 0x6e, 0x06, 0x33, 0x57, 0xff,
-       0xf1, 0x78, 0xa1, 0xaa, 0x1b, 0xe7, 0x30, 0xdd,
-       0x14, 0xa2, 0x6e, 0x0e, 0x92, 0x8d, 0x94, 0x20,
-       0xdf, 0xb1, 0xf0, 0x1b, 0x4c, 0x37, 0x47, 0x0a,
-       0x55, 0xdd, 0x38, 0x51, 0x37, 0x85, 0xaa, 0x6e,
-       0x9c, 0x9f, 0xa7, 0x9b, 0x67, 0xfd, 0x50, 0xa8,
-       0xea, 0xc6, 0xc9, 0x43, 0xa8, 0x1b, 0x35, 0xf4,
-       0xe2, 0xad, 0xeb, 0x9c, 0x10, 0x70, 0x16, 0x72,
-       0xdd, 0x60, 0x7c, 0x8d, 0xe7, 0x06, 0xdd, 0x2c,
-       0xe1, 0xba, 0xc9, 0x10, 0xaf, 0xd3, 0xce, 0xd6,
-       0x2f, 0xfe, 0xc7, 0xb5, 0xf3, 0xc7, 0xf3, 0xe8,
-       0x47, 0x5f, 0xfe, 0x62, 0x0d, 0x8d, 0x62, 0xfb,
-       0x73, 0x1e, 0xb9, 0xca, 0xee, 0xec, 0x54, 0xe4,
-       0xe8, 0xb3, 0x75, 0x74, 0xdf, 0xf4, 0x9f, 0x9a,
-       0x7d, 0x4f, 0x29, 0x36, 0x16, 0xda, 0x81, 0x21,
-       0x13, 0x72, 0x83, 0x0e, 0x47, 0x71, 0xeb, 0x71,
-       0x7a, 0x27, 0x5a, 0x77, 0x3e, 0xd3, 0x95, 0x4e,
-       0xbe, 0xd8, 0xe8, 0xf9, 0x1e, 0xd8, 0xf1, 0x67,
-       0xf3, 0x4c, 0x86, 0x62, 0xfc, 0x4d, 0x97, 0x20,
-       0x79, 0x2f, 0x9d, 0x3b, 0xc3, 0xfd, 0xb2, 0x30,
-       0x19, 0x8c, 0xf4, 0x25, 0x20, 0xfb, 0xa0, 0x04,
-       0x29, 0x69, 0xaa, 0x94, 0x97, 0x7d, 0xdf, 0x5a,
-       0x0a, 0xba, 0x02, 0x4c, 0x95, 0x2a, 0xc1, 0xa8,
-       0xad, 0x4b, 0x93, 0x71, 0x8c, 0x33, 0xb3, 0x79,
-       0x00, 0xc5, 0x6e, 0x44, 0x7f, 0x6f, 0xc6, 0x9f,
-       0x15, 0x25, 0xed, 0xca, 0x36, 0x78, 0x12, 0x54,
-       0x49, 0x74, 0x7e, 0xd3, 0x02, 0x5f, 0x82, 0x6c,
-       0xe9, 0xf9, 0x1e, 0x98, 0x1b, 0x8c, 0xd5, 0x3f,
-       0xcd, 0x36, 0x30, 0xc9, 0xdb, 0x25, 0x18, 0xbd,
-       0x57, 0x49, 0xc1, 0x9c, 0xcc, 0x12, 0xd8, 0x16,
-       0x23, 0x36, 0x83, 0xc9, 0xf1, 0xe2, 0x6c, 0xbc,
-       0x07, 0x65, 0x5c, 0x95, 0xc7, 0xaa, 0x71, 0x33,
-       0x30, 0x8e, 0x66, 0x4c, 0x49, 0xb1, 0xbc, 0x32,
-       0x9c, 0xc5, 0xba, 0x7e, 0xf1, 0x59, 0x5f, 0x82,
-       0x62, 0xdd, 0xfb, 0xa8, 0x62, 0x16, 0x4c, 0x4c,
-       0x22, 0x9d, 0x97, 0x0c, 0xa0, 0xd3, 0x0d, 0x2a,
-       0x16, 0x7a, 0x56, 0x8e, 0xf9, 0x19, 0xe9, 0x6d,
-       0xac, 0xe4, 0xcc, 0x6c, 0x2c, 0xc3, 0xc4, 0xef,
-       0x91, 0x12, 0x45, 0x4b, 0xb6, 0x43, 0xd7, 0x3f,
-       0xb1, 0x05, 0xcc, 0xba, 0x7e, 0x6d, 0x04, 0xb2,
-       0x0d, 0xe0, 0x9c, 0x1e, 0x6e, 0x2b, 0xe0, 0xdf,
-       0x69, 0x09, 0x3c, 0xe2, 0x79, 0x46, 0x3d, 0x1b,
-       0x89, 0x46, 0x24, 0x1a, 0x3d, 0xf5, 0xc4, 0x0f,
-       0xc6, 0x0a, 0x2c, 0x97, 0x9b, 0x4e, 0x50, 0x4a,
-       0x74, 0x1c, 0x1f, 0xe2, 0xc0, 0x38, 0xa3, 0xee,
-       0xf2, 0x44, 0x7a, 0x73, 0xf4, 0x33, 0xdd, 0xe0,
-       0xc4, 0x72, 0x5d, 0x3f, 0x4a, 0xdc, 0xc1, 0x4b,
-       0x6e, 0x3f, 0x8d, 0xe1, 0x66, 0x31, 0x28, 0xc1,
-       0xc8, 0xed, 0x43, 0xda, 0x60, 0x77, 0xb3, 0x12,
-       0xd5, 0xba, 0xd4, 0x49, 0x70, 0xeb, 0x16, 0xe4,
-       0xda, 0xa9, 0x90, 0x3f, 0xf0, 0xf1, 0xba, 0x8f,
-       0x1c, 0x54, 0x4c, 0xac, 0x86, 0x87, 0x79, 0x2a,
-       0x4d, 0xb3, 0x93, 0x9a, 0x75, 0xa5, 0x90, 0xca,
-       0xde, 0xcd, 0xc5, 0xbc, 0x94, 0xb1, 0xf4, 0x2d,
-       0x58, 0x56, 0x67, 0x3d, 0x62, 0xf1, 0x52, 0xf5,
-       0x42, 0x12, 0xcd, 0x18, 0x3c, 0x4f, 0xd1, 0x29,
-       0x15, 0xbe, 0x30, 0xb7, 0x13, 0xdf, 0x5a, 0xa5,
-       0x34, 0xdd, 0x9d, 0x39, 0x8f, 0x5a, 0xd9, 0x87,
-       0xad, 0xae, 0x64, 0x63, 0x2b, 0x1e, 0x56, 0xeb,
-       0xc9, 0xca, 0x7b, 0x6b, 0x32, 0xd6, 0x26, 0x55,
-       0x57, 0xea, 0xdb, 0x81, 0x63, 0x97, 0x69, 0x62,
-       0xb3, 0xae, 0x80, 0xe6, 0x33, 0xa3, 0x4e, 0x60,
-       0x4d, 0xd2, 0xf0, 0xb7, 0xae, 0xea, 0x45, 0xb0,
-       0x7a, 0x9e, 0x22, 0x1f, 0x4e, 0x67, 0x5f, 0x90,
-       0x4c, 0x4d, 0x9e, 0x63, 0x32, 0xa4, 0x6e, 0x41,
-       0x8b, 0xda, 0xfd, 0x58, 0xbb, 0x3e, 0xd3, 0xe8,
-       0x7b, 0x14, 0x2d, 0xcd, 0xe2, 0xf0, 0xa0, 0xd4,
-       0xd8, 0x38, 0x9f, 0xb6, 0x13, 0x25, 0x1d, 0xc1,
-       0x39, 0xc6, 0x25, 0xa4, 0xda, 0x37, 0xa2, 0xe5,
-       0xd1, 0x69, 0x4d, 0x1b, 0x61, 0x79, 0x8a, 0xe0,
-       0xd0, 0x5d, 0xa5, 0xda, 0x99, 0xbe, 0x47, 0x38,
-       0xd8, 0xc4, 0x43, 0x28, 0xcd, 0x8e, 0xd2, 0x6c,
-       0xc1, 0xa4, 0x33, 0x2f, 0x95, 0x96, 0x1e, 0xef,
-       0x82, 0x59, 0x5c, 0xca, 0x87, 0x95, 0x82, 0xd3,
-       0x65, 0x3f, 0x5b, 0x99, 0x8e, 0xf1, 0xfb, 0x31,
-       0xb5, 0x2e, 0xaa, 0x9d, 0xbb, 0x93, 0x56, 0x9b,
-       0xc5, 0xce, 0xf7, 0xde, 0xba, 0xf6, 0xb5, 0x47,
-       0x5b, 0x57, 0x73, 0xea, 0xbb, 0xfb, 0x9e, 0xfe,
-       0xe6, 0xbf, 0x61, 0x99, 0x6a, 0xca, 0xec, 0xc7,
-       0x71, 0x4d, 0x3d, 0x58, 0x53, 0xba, 0x34, 0x5d,
-       0x6d, 0x05, 0x35, 0x47, 0x4c, 0x37, 0x0e, 0x4b,
-       0x55, 0x28, 0x2f, 0x59, 0x39, 0x4b, 0xcb, 0x7d,
-       0x78, 0x4e, 0xbb, 0xd9, 0x37, 0xa2, 0x96, 0x8f,
-       0x13, 0x2a, 0x25, 0xb8, 0xa5, 0xbf, 0xe2, 0x82,
-       0x1e, 0x88, 0x0f, 0x47, 0x34, 0xfb, 0xd3, 0x2c,
-       0x46, 0x7e, 0x51, 0x14, 0xb4, 0x32, 0xdc, 0xd2,
-       0x1b, 0x04, 0x2d, 0xe7, 0x7f, 0xa5, 0x7c, 0x4b,
-       0x30, 0xdf, 0xb7, 0xa2, 0x83, 0xea, 0x6c, 0xcd,
-       0xab, 0xb0, 0x5e, 0x3b, 0xa4, 0xb9, 0xea, 0x73,
-       0x50, 0xcc, 0xb5, 0x47, 0x67, 0x6d, 0x6d, 0x24,
-       0xed, 0x85, 0xdb, 0xc7, 0xd2, 0xb7, 0x5b, 0xa4,
-       0x1c, 0xf5, 0x3e, 0xa3, 0xed, 0x58, 0xf8, 0xe9,
-       0x30, 0x59, 0xa7, 0xce, 0x2b, 0x1a, 0x11, 0x62,
-       0x2b, 0x24, 0xdb, 0x6f, 0x26, 0x2f, 0x7a, 0xd5,
-       0xe1, 0xc9, 0x84, 0x78, 0x7d, 0xdf, 0x82, 0x2b,
-       0xa5, 0x64, 0x7a, 0xcb, 0xd0, 0xfc, 0x7f, 0x42,
-       0xdf, 0xa9, 0x67, 0xe3, 0xf4, 0xcd, 0x57, 0x1a,
-       0xc3, 0x34, 0x6e, 0x3b, 0x49, 0x1a, 0x8f, 0x69,
-       0xe6, 0xf8, 0xcd, 0x74, 0x9f, 0xfa, 0x1c, 0x5a,
-       0xfa, 0x6b, 0xb2, 0xfc, 0xa5, 0x74, 0xff, 0x34,
-       0xe9, 0x9e, 0xeb, 0x5c, 0x6b, 0x01, 0xd4, 0x7d,
-       0x56, 0xac, 0x3c, 0xb5, 0xd7, 0xeb, 0x1e, 0x4b,
-       0xf0, 0x56, 0x5c, 0x09, 0x16, 0x0c, 0x3d, 0x57,
-       0xb8, 0x5e, 0x53, 0xf4, 0xf6, 0xdc, 0xc8, 0x3c,
-       0x19, 0xf4, 0xa6, 0xeb, 0x34, 0xb5, 0x9a, 0xca,
-       0x2a, 0xe3, 0x6a, 0xc4, 0xf2, 0xf2, 0x52, 0xe4,
-       0x33, 0x75, 0x6b, 0xfe, 0x0e, 0x3d, 0xd0, 0x09,
-       0x9e, 0x7a, 0xa2, 0x4b, 0x77, 0x95, 0xd6, 0xaa,
-       0xd6, 0xdd, 0x24, 0x11, 0x65, 0x5d, 0x14, 0x26,
-       0xf0, 0x98, 0xe0, 0x23, 0x9e, 0x2d, 0xf4, 0xec,
-       0x46, 0xad, 0x35, 0x9b, 0x85, 0xb3, 0x77, 0x53,
-       0xc9, 0xf7, 0xc4, 0xfc, 0x05, 0xa6, 0xec, 0xc2,
-       0x54, 0x7b, 0x86, 0xb5, 0x07, 0x44, 0xeb, 0xb5,
-       0x16, 0x11, 0x8c, 0xd7, 0xb7, 0x49, 0xa4, 0x4b,
-       0x17, 0xc5, 0x31, 0xed, 0x84, 0xa6, 0x25, 0xad,
-       0x86, 0x63, 0xfc, 0x43, 0xad, 0xf4, 0xee, 0xbe,
-       0xd2, 0xb5, 0x47, 0x99, 0xae, 0x76, 0x3e, 0xda,
-       0xae, 0x4f, 0x37, 0xfc, 0x02, 0x3d, 0x36, 0xfe,
-       0xec, 0x4f, 0xaf, 0x15, 0xf5, 0xa8, 0x97, 0x37,
-       0x87, 0xf4, 0x92, 0x3a, 0x83, 0xf5, 0x55, 0x2b,
-       0xb6, 0x0f, 0xb6, 0xa2, 0x04, 0x49, 0x07, 0x62,
-       0xed, 0xc4, 0xea, 0x33, 0x02, 0xc7, 0xa2, 0x54,
-       0x5c, 0xaf, 0x27, 0x3c, 0x31, 0x54, 0x77, 0x78,
-       0x7f, 0x78, 0xdd, 0x47, 0xbc, 0xc6, 0x79, 0xc7,
-       0x5c, 0xfa, 0xf3, 0xea, 0x1e, 0x5f, 0x67, 0x94,
-       0x12, 0x42, 0x09, 0x3d, 0x2b, 0x67, 0x61, 0x19,
-       0x5c, 0x4b, 0x85, 0x61, 0x65, 0xc0, 0xb1, 0x61,
-       0x0c, 0xae, 0x53, 0x12, 0xcc, 0xb1, 0x32, 0x2c,
-       0xe6, 0xf1, 0x7e, 0xf4, 0x53, 0x1f, 0x56, 0x4e,
-       0x0c, 0x93, 0x1e, 0x04, 0xd5, 0x5e, 0xda, 0x71,
-       0xfd, 0x33, 0xa6, 0x99, 0xd6, 0xe1, 0x63, 0xea,
-       0x05, 0x66, 0xa3, 0xd8, 0xab, 0x6c, 0xbf, 0x8c,
-       0x3c, 0x1d, 0x7e, 0x17, 0x35, 0x80, 0xbf, 0x54,
-       0xd4, 0x6f, 0x0a, 0xda, 0x48, 0x2a, 0xd9, 0x49,
-       0x7c, 0x3e, 0x96, 0x4b, 0x98, 0x26, 0x47, 0xb3,
-       0x13, 0xea, 0xa1, 0xbe, 0x47, 0x97, 0x8e, 0xdb,
-       0x85, 0x5c, 0xad, 0xb6, 0x49, 0x34, 0x02, 0x58,
-       0x69, 0xbc, 0xc4, 0xb1, 0xd3, 0x2e, 0x16, 0xb1,
-       0x6b, 0x9e, 0xef, 0x51, 0x39, 0xd5, 0xb7, 0x6e,
-       0xa9, 0x65, 0x28, 0xf6, 0x5f, 0x90, 0x5b, 0x1c,
-       0x8b, 0x2d, 0x91, 0xba, 0x69, 0xdd, 0x4e, 0x4a,
-       0x19, 0x17, 0x37, 0xc9, 0x0d, 0x76, 0xb2, 0x30,
-       0x1c, 0x97, 0x52, 0xdb, 0x4d, 0x48, 0x4f, 0x05,
-       0xbb, 0x0f, 0x79, 0x96, 0xb2, 0xb1, 0x78, 0xa8,
-       0x27, 0xf3, 0xf1, 0xfc, 0x0b, 0x46, 0x73, 0xb4,
-       0x98, 0x04, 0x0b, 0x1b, 0xcd, 0x83, 0x37, 0x1b,
-       0xcd, 0xd1, 0x52, 0x2f, 0xdd, 0x38, 0x92, 0x8f,
-       0xce, 0xc3, 0x1a, 0xd2, 0x37, 0x6c, 0x66, 0xf0,
-       0xf1, 0x3b, 0xf1, 0xc4, 0x75, 0xe3, 0x77, 0xe6,
-       0xd0, 0xf8, 0x6d, 0xba, 0xfc, 0xa7, 0xc7, 0x6f,
-       0xdb, 0x19, 0x6c, 0xa9, 0x41, 0x6d, 0xfc, 0x36,
-       0x6f, 0x45, 0x6c, 0x0d, 0xc9, 0x41, 0xeb, 0x60,
-       0x63, 0x58, 0x62, 0x91, 0x36, 0x7e, 0x9b, 0xd7,
-       0x60, 0x5c, 0x7d, 0xfc, 0xf8, 0x0d, 0xaf, 0xdd,
-       0x6c, 0xfc, 0xb6, 0x6d, 0xbc, 0xf9, 0xf8, 0x6d,
-       0x92, 0xbf, 0x78, 0xfc, 0x4e, 0x9a, 0x46, 0x1e,
-       0x72, 0x74, 0xe8, 0x2f, 0x1b, 0xbf, 0xf9, 0x28,
-       0xca, 0xc7, 0x6f, 0x73, 0x1f, 0x2f, 0xf9, 0x68,
-       0x01, 0xc3, 0x3b, 0x10, 0x76, 0xe3, 0xc8, 0x67,
-       0xe6, 0xa3, 0xdf, 0x90, 0x1f, 0xe1, 0xed, 0x24,
-       0xb8, 0xe9, 0xeb, 0x5f, 0xf3, 0xbb, 0x5f, 0xd9,
-       0xb7, 0xdc, 0x6e, 0xb5, 0xc3, 0x54, 0xc5, 0x1a,
-       0xff, 0x1d, 0x30, 0xfc, 0x49, 0x1e, 0x7b, 0x5c,
-       0x5b, 0x26, 0xc7, 0xda, 0x92, 0xc6, 0xfb, 0xf1,
-       0x12, 0x18, 0x5c, 0xb4, 0xa7, 0xdb, 0xfb, 0x29,
-       0x24, 0x20, 0xbd, 0x0f, 0xf3, 0x1a, 0x97, 0xe9,
-       0xa2, 0xd6, 0xa3, 0xdc, 0xb4, 0xbc, 0xc2, 0x6a,
-       0x5e, 0x44, 0xa7, 0xbb, 0x98, 0xb3, 0x6c, 0x5a,
-       0xff, 0x1d, 0xb5, 0x24, 0xa6, 0xb3, 0xb4, 0xdb,
-       0x8a, 0x61, 0xaa, 0x54, 0x2b, 0x8f, 0x93, 0x32,
-       0xa5, 0x2a, 0x39, 0x0d, 0x7d, 0xd7, 0x65, 0xf9,
-       0xb8, 0x98, 0x8a, 0xd4, 0x69, 0xd2, 0x0c, 0xd9,
-       0xe4, 0xfe, 0x35, 0xa4, 0x49, 0x63, 0xc9, 0x97,
-       0x1e, 0xd7, 0xa3, 0x5c, 0x9d, 0xba, 0x0b, 0x80,
-       0xce, 0xaf, 0x33, 0x6a, 0xcf, 0xfd, 0xe9, 0x1b,
-       0x85, 0xef, 0x46, 0x44, 0xd3, 0x6d, 0x82, 0x64,
-       0x95, 0x8d, 0x7c, 0x7d, 0xab, 0xae, 0x1f, 0xcd,
-       0xaf, 0x0e, 0xc2, 0xf6, 0xf2, 0xfd, 0xb2, 0xc5,
-       0xb1, 0x37, 0x07, 0xff, 0x02, 0x51, 0x9c, 0x83,
-       0xe2, 0x3c, 0xc0, 0x86, 0xb1, 0xaa, 0x1e, 0xee,
-       0x06, 0xf3, 0x99, 0x6e, 0xad, 0x5c, 0xc9, 0x07,
-       0xd0, 0x02, 0xde, 0xe7, 0xf6, 0x0a, 0x7a, 0x8d,
-       0x87, 0x7a, 0xd5, 0xce, 0xbd, 0xa4, 0x09, 0xc5,
-       0xcc, 0xe0, 0x0e, 0xb9, 0x5c, 0x9b, 0x41, 0xc4,
-       0xcf, 0x43, 0x92, 0xd1, 0x13, 0x25, 0x3e, 0x87,
-       0x73, 0x85, 0x3e, 0xac, 0x05, 0x7d, 0x1b, 0xe9,
-       0x05, 0x09, 0x8c, 0x22, 0x6f, 0x6f, 0x77, 0x3f,
-       0x18, 0x5f, 0x19, 0x84, 0x6d, 0xaf, 0xd0, 0xb9,
-       0xc0, 0xdd, 0x82, 0x5d, 0xa1, 0x3b, 0x49, 0xeb,
-       0x87, 0x5a, 0xa1, 0xd5, 0x28, 0xb8, 0xc5, 0x94,
-       0xcf, 0x6b, 0x89, 0xcf, 0xeb, 0x53, 0x10, 0xc6,
-       0x31, 0x76, 0x37, 0xb6, 0xc4, 0x8a, 0xf4, 0x70,
-       0x4e, 0x78, 0x2a, 0xf6, 0x28, 0xde, 0x0a, 0xd4,
-       0xb7, 0xa8, 0x07, 0x69, 0xb6, 0x36, 0xf2, 0x02,
-       0x96, 0xcc, 0x24, 0x57, 0x55, 0xf4, 0x81, 0x3d,
-       0x38, 0x4b, 0x18, 0x27, 0x5b, 0xe8, 0x1e, 0x2e,
-       0xcd, 0x89, 0x44, 0x17, 0xf5, 0x1f, 0xad, 0xfe,
-       0x23, 0xb1, 0xfe, 0xa6, 0xf7, 0xe5, 0x4c, 0x3e,
-       0x63, 0xab, 0x40, 0xab, 0xd3, 0x66, 0x6d, 0x0b,
-       0xce, 0xc1, 0x74, 0xea, 0x21, 0x9a, 0x15, 0x0a,
-       0x49, 0xa2, 0x09, 0xd3, 0x47, 0x45, 0xb3, 0x3a,
-       0xe6, 0x5f, 0xd2, 0x3c, 0xc1, 0x69, 0x57, 0x48,
-       0x27, 0xc1, 0xe5, 0xf1, 0x58, 0x2a, 0x53, 0xba,
-       0x4b, 0x32, 0x93, 0xed, 0xf1, 0xbd, 0x12, 0x9a,
-       0xed, 0xc5, 0x66, 0x0f, 0xd8, 0xc3, 0x63, 0x25,
-       0xf4, 0x61, 0xce, 0x8d, 0xa8, 0xb3, 0x13, 0xe9,
-       0x4c, 0x97, 0x06, 0xc7, 0xce, 0x1e, 0xec, 0xc1,
-       0xe3, 0x58, 0x3f, 0x06, 0x38, 0x40, 0x3d, 0x6d,
-       0x64, 0x26, 0xf2, 0xb8, 0xe8, 0xcb, 0x32, 0xac,
-       0x1f, 0xbe, 0x5f, 0x00, 0x82, 0x2e, 0x56, 0x72,
-       0x0b, 0xc6, 0x65, 0xd0, 0xf7, 0xa2, 0x34, 0xcb,
-       0x62, 0xf3, 0xd5, 0x64, 0xd5, 0xf7, 0x3f, 0xa6,
-       0xcd, 0x37, 0xe5, 0x54, 0x37, 0xea, 0x20, 0x30,
-       0xcb, 0xb7, 0x45, 0x3e, 0x4d, 0xcf, 0xf0, 0xb5,
-       0x3b, 0x38, 0x5a, 0xbf, 0x9c, 0x88, 0x2b, 0x4a,
-       0xea, 0x97, 0x09, 0xcf, 0xa0, 0xcc, 0xe3, 0x31,
-       0x5f, 0x84, 0x25, 0xb2, 0x62, 0x8f, 0x4a, 0xd8,
-       0x2f, 0x17, 0x71, 0x4c, 0x6b, 0xd7, 0x74, 0x07,
-       0x98, 0xb1, 0x87, 0x16, 0x89, 0x26, 0x21, 0x03,
-       0xa9, 0x3e, 0xba, 0xf3, 0x4c, 0xe3, 0xaf, 0x82,
-       0x65, 0xb2, 0xae, 0xc0, 0x14, 0x1b, 0x65, 0xf4,
-       0xec, 0xc6, 0x3c, 0xb1, 0x17, 0xc3, 0xe8, 0xbf,
-       0x46, 0x5e, 0xd6, 0x7a, 0xc7, 0x04, 0x6d, 0x05,
-       0xa4, 0xcb, 0x5c, 0x45, 0x7d, 0x28, 0x1b, 0x57,
-       0x4d, 0xff, 0x74, 0x81, 0xec, 0x9d, 0xb5, 0x71,
-       0x7f, 0x20, 0x31, 0x9d, 0x6b, 0x7a, 0x96, 0xcf,
-       0xa6, 0xac, 0x44, 0xcb, 0x98, 0x26, 0x5f, 0xa9,
-       0xe9, 0x7e, 0xea, 0x67, 0x82, 0x99, 0xc6, 0x79,
-       0x18, 0xdf, 0xae, 0x0f, 0x8c, 0xe7, 0x9c, 0x42,
-       0x45, 0x30, 0x91, 0x8f, 0x5c, 0x29, 0x11, 0x61,
-       0x56, 0x1e, 0x88, 0x66, 0x7a, 0x8b, 0xe2, 0xe7,
-       0xde, 0x14, 0xb6, 0xf7, 0xd1, 0xdf, 0x9d, 0xc3,
-       0xda, 0xf7, 0x9f, 0xf8, 0x13, 0x12, 0xb1, 0x04,
-       0x73, 0x70, 0x78, 0x03, 0x89, 0xaf, 0x3e, 0x2e,
-       0x5b, 0x49, 0x03, 0xd9, 0xd4, 0x03, 0x9e, 0x14,
-       0xd3, 0x84, 0x31, 0x0a, 0x5a, 0x8f, 0x48, 0x7b,
-       0x7f, 0x2d, 0x31, 0xef, 0x8a, 0x72, 0x74, 0x63,
-       0xd5, 0x16, 0x1e, 0x67, 0xfd, 0x3e, 0x3d, 0x83,
-       0x80, 0x14, 0xc5, 0xce, 0x42, 0x06, 0x0c, 0x91,
-       0x2f, 0xb6, 0xc6, 0xfc, 0xe3, 0x79, 0xd6, 0xae,
-       0x54, 0x5e, 0x5c, 0xd1, 0x93, 0x2d, 0xcb, 0x97,
-       0x6b, 0xba, 0x5f, 0xf9, 0x99, 0x9c, 0xe5, 0xff,
-       0x16, 0x3b, 0xfb, 0x93, 0xb5, 0xd4, 0x08, 0x11,
-       0xf5, 0xb1, 0x1a, 0x5b, 0xea, 0xb9, 0x6c, 0xea,
-       0xeb, 0x47, 0xd4, 0xe7, 0x2a, 0x5c, 0xc2, 0x8e,
-       0xa7, 0x7e, 0x96, 0x61, 0x8e, 0xab, 0xd5, 0xdf,
-       0x51, 0xad, 0x6c, 0xfb, 0xd3, 0x67, 0xb1, 0xef,
-       0x11, 0x1e, 0x8e, 0x0e, 0xe6, 0x24, 0xf9, 0xbf,
-       0x35, 0x74, 0xc7, 0x70, 0x04, 0x6a, 0xd4, 0x98,
-       0xc3, 0xce, 0xe5, 0xc4, 0x14, 0xb6, 0xbb, 0xe1,
-       0x16, 0x2c, 0xaf, 0x91, 0xc7, 0x93, 0xf7, 0x55,
-       0xf2, 0x88, 0xcb, 0x72, 0x11, 0xb9, 0xcc, 0x72,
-       0x0e, 0xe7, 0x2a, 0x51, 0x4f, 0xbf, 0xd4, 0x3d,
-       0xa8, 0xae, 0x56, 0x7a, 0xad, 0xaf, 0x92, 0x6d,
-       0xc0, 0xb6, 0x5d, 0x56, 0x05, 0xa2, 0x33, 0xe2,
-       0xca, 0x63, 0xa7, 0xba, 0x30, 0x3b, 0xd2, 0xc6,
-       0x00, 0x93, 0x30, 0x22, 0x3d, 0x31, 0xc3, 0x84,
-       0x6d, 0x78, 0x95, 0xf9, 0x97, 0xfe, 0x21, 0x0f,
-       0x17, 0x00, 0x3a, 0xf5, 0x14, 0xad, 0x7e, 0xfc,
-       0x52, 0x13, 0x9d, 0x82, 0x2a, 0xaa, 0xf7, 0x3d,
-       0x3d, 0x1b, 0x31, 0x66, 0xd3, 0x5d, 0xab, 0x28,
-       0x8c, 0x54, 0x93, 0x0f, 0xe3, 0x94, 0xb3, 0xb8,
-       0x0e, 0x26, 0x5f, 0x66, 0xa1, 0xb3, 0x6d, 0x3d,
-       0x5b, 0x87, 0xff, 0x23, 0x9a, 0x64, 0xcc, 0x60,
-       0xde, 0xed, 0x74, 0xff, 0xac, 0xf3, 0xa0, 0x13,
-       0xdc, 0x81, 0x3b, 0x42, 0x51, 0xbf, 0x27, 0xed,
-       0xf8, 0x42, 0xda, 0x37, 0xa2, 0x0f, 0x8d, 0x4f,
-       0x5d, 0x87, 0x12, 0xf8, 0x79, 0x48, 0x61, 0x61,
-       0x9e, 0xcd, 0x01, 0xb7, 0xd0, 0x18, 0x21, 0x99,
-       0xf8, 0x5d, 0x6b, 0xef, 0xc7, 0x81, 0x48, 0x1a,
-       0x90, 0x5f, 0x2c, 0xc0, 0x35, 0x7e, 0x1e, 0x86,
-       0xf6, 0x0f, 0xc2, 0x48, 0x9b, 0x7d, 0x77, 0x31,
-       0x18, 0xd8, 0x9b, 0x4b, 0x7f, 0x50, 0xcc, 0x52,
-       0x3a, 0xcd, 0x36, 0xde, 0x4a, 0x3f, 0xea, 0xda,
-       0xdf, 0x95, 0x18, 0x45, 0xdd, 0xbe, 0xbf, 0x6e,
-       0x10, 0xbc, 0x5e, 0xf7, 0x12, 0xb7, 0x53, 0xf7,
-       0xa1, 0xb7, 0xf2, 0x94, 0x81, 0xad, 0xd3, 0x45,
-       0x1c, 0xee, 0xd3, 0x8b, 0xd7, 0x88, 0xab, 0x25,
-       0x73, 0x18, 0x12, 0x15, 0xbd, 0xd7, 0xdd, 0xa3,
-       0x5b, 0x6e, 0x39, 0xfd, 0x78, 0x8f, 0xae, 0xcd,
-       0x68, 0x5e, 0x07, 0x09, 0x36, 0xf4, 0xca, 0xc0,
-       0xee, 0x79, 0x80, 0xab, 0x44, 0x2d, 0x81, 0x9e,
-       0x95, 0xe0, 0x74, 0xc4, 0x76, 0x5b, 0x8f, 0x5d,
-       0x16, 0x82, 0x90, 0x02, 0x62, 0x8a, 0xed, 0x36,
-       0x09, 0x0e, 0xef, 0x4e, 0x05, 0xb2, 0xcc, 0xc3,
-       0x2f, 0xef, 0x02, 0xd9, 0x8c, 0x2d, 0x7b, 0x41,
-       0xbb, 0x27, 0x60, 0x48, 0xe4, 0x73, 0x17, 0xee,
-       0x19, 0x7e, 0xf4, 0x29, 0x9d, 0x1c, 0xab, 0xac,
-       0xc4, 0x36, 0x3a, 0x43, 0x5f, 0x62, 0xdf, 0x9d,
-       0x3a, 0xdc, 0x4b, 0x27, 0x8d, 0x2f, 0x2a, 0xd6,
-       0x15, 0x4f, 0x2b, 0xd6, 0x3d, 0xc7, 0xce, 0x1c,
-       0xc2, 0x96, 0xdb, 0x4d, 0x76, 0xba, 0x5b, 0xb5,
-       0x0b, 0xa7, 0x0b, 0x26, 0x45, 0x90, 0xc6, 0x46,
-       0x9b, 0x5d, 0xc8, 0x6f, 0xbe, 0x28, 0x15, 0xfb,
-       0xc2, 0xcb, 0x9c, 0x72, 0x8e, 0x09, 0x5b, 0x7a,
-       0xd4, 0x69, 0xe2, 0xaf, 0x2b, 0xdd, 0x53, 0x26,
-       0x6b, 0xab, 0x48, 0x67, 0x35, 0x7a, 0x17, 0xf3,
-       0x21, 0x94, 0x38, 0xb8, 0x12, 0xc4, 0x5d, 0x52,
-       0x32, 0x72, 0xeb, 0x95, 0xb0, 0x2f, 0xac, 0xf9,
-       0xb4, 0x40, 0x98, 0xc9, 0x4a, 0x15, 0xee, 0xa5,
-       0xb4, 0x99, 0x58, 0x9a, 0x74, 0xbb, 0x6c, 0x09,
-       0x0a, 0xbd, 0x6b, 0x7b, 0x1e, 0x6d, 0x1d, 0x2f,
-       0xda, 0x42, 0x13, 0xce, 0x3c, 0xde, 0x34, 0xd6,
-       0x1f, 0x46, 0x8c, 0xce, 0x03, 0xbc, 0x4c, 0x9e,
-       0x7e, 0xb7, 0x4d, 0x3e, 0x81, 0xf5, 0x73, 0xa2,
-       0x8f, 0xcc, 0x4e, 0x87, 0x4d, 0x74, 0x1a, 0xae,
-       0x3d, 0x43, 0x77, 0x7e, 0x03, 0x97, 0xf4, 0xe1,
-       0x86, 0x4c, 0xa7, 0x03, 0x68, 0xde, 0x0b, 0x13,
-       0x0c, 0x8f, 0x4e, 0x7c, 0xd4, 0x41, 0x3b, 0x5d,
-       0xb6, 0xed, 0x1e, 0x47, 0x79, 0xea, 0x92, 0xd5,
-       0xbd, 0x4a, 0x4c, 0x1b, 0x39, 0xc0, 0xf5, 0x21,
-       0xcf, 0xc8, 0x01, 0x9e, 0xff, 0xeb, 0xe1, 0xe5,
-       0x79, 0x74, 0xb6, 0xde, 0xa8, 0xd3, 0xaf, 0x87,
-       0x5b, 0x1d, 0xe9, 0x89, 0x5f, 0x28, 0xfb, 0x0d,
-       0x92, 0x8d, 0x3d, 0xeb, 0x09, 0x7a, 0xe2, 0x94,
-       0x9d, 0xf8, 0xc4, 0xe0, 0xa8, 0xd3, 0xde, 0x83,
-       0x37, 0xd3, 0x6a, 0xe2, 0x21, 0xe4, 0x38, 0x23,
-       0x37, 0xdf, 0xa8, 0x5b, 0xdf, 0x7a, 0xc5, 0x31,
-       0xa4, 0xb9, 0x9a, 0xf5, 0x75, 0xa5, 0xaf, 0x95,
-       0xca, 0xe7, 0x87, 0xb4, 0x8d, 0x69, 0x9f, 0x58,
-       0x09, 0xa4, 0x3d, 0xf1, 0xd8, 0xe7, 0xb5, 0x41,
-       0x22, 0xbd, 0x3b, 0xf3, 0x98, 0x6c, 0xc1, 0x59,
-       0x6c, 0x35, 0xaf, 0x69, 0x6c, 0x96, 0xd0, 0x4f,
-       0xf7, 0x63, 0x77, 0x8f, 0x53, 0xd2, 0x3d, 0x0c,
-       0x92, 0x37, 0xdc, 0x9d, 0xaa, 0x8d, 0xad, 0x98,
-       0xd6, 0xc9, 0x6a, 0x4d, 0xed, 0xe8, 0xe5, 0xbd,
-       0x86, 0xed, 0x38, 0xf3, 0x7a, 0x76, 0x40, 0x6a,
-       0x10, 0x02, 0x8f, 0x1c, 0xa5, 0x3b, 0x73, 0x83,
-       0xa5, 0x6b, 0x71, 0x9e, 0x9a, 0x1a, 0xb7, 0x23,
-       0xcd, 0xeb, 0xd9, 0x18, 0x1f, 0x9b, 0xbe, 0x36,
-       0x16, 0x87, 0xf3, 0x85, 0xe0, 0x84, 0xde, 0x2d,
-       0xfc, 0x1f, 0xdb, 0x8f, 0x1d, 0x56, 0x2c, 0xea,
-       0x93, 0x2d, 0x2f, 0xbb, 0xc3, 0x4b, 0x4f, 0x3e,
-       0xbe, 0xfe, 0x97, 0xed, 0xc2, 0xfc, 0x4f, 0x48,
-       0x8f, 0xbe, 0x1a, 0xc0, 0x10, 0x80, 0xaf, 0xfe,
-       0xbe, 0xfa, 0xfb, 0xea, 0xef, 0xab, 0xbf, 0xaf,
-       0xfe, 0xbe, 0xfa, 0xfb, 0x52, 0xfb, 0xff, 0x23,
-       0xea, 0xac, 0x54, 0xa2, 0xaf, 0x1c, 0x6f, 0xdb,
-       0x53, 0x94, 0xee, 0xf6, 0x7d, 0x0f, 0xac, 0xcb,
-       0xd2, 0x7f, 0x74, 0x0e, 0xcc, 0xf2, 0xb8, 0x1e,
-       0x0c, 0xcb, 0x69, 0x9e, 0x16, 0xb0, 0x65, 0xb4,
-       0x80, 0xd1, 0x59, 0x0c, 0x33, 0x85, 0x13, 0xc2,
-       0x09, 0xb6, 0xdb, 0x3a, 0x3b, 0x7d, 0xb4, 0x7c,
-       0x54, 0xaa, 0x9d, 0x34, 0x9b, 0xdf, 0x51, 0xf1,
-       0x4c, 0x86, 0x14, 0xc6, 0x47, 0xeb, 0xfa, 0x4d,
-       0x1a, 0x77, 0xc6, 0xf1, 0x0c, 0xb6, 0x37, 0x1b,
-       0xc7, 0x62, 0x36, 0x9e, 0xba, 0x5c, 0xc3, 0x72,
-       0xb1, 0x5a, 0x5b, 0x1e, 0x89, 0x82, 0x4d, 0x31,
-       0xfa, 0x31, 0x25, 0xca, 0xeb, 0xc3, 0xf9, 0x20,
-       0xdf, 0x51, 0xdf, 0x13, 0x88, 0x0e, 0xe3, 0x0c,
-       0xf6, 0x20, 0x47, 0x5b, 0xf2, 0x72, 0x93, 0x0f,
-       0xf3, 0x91, 0x4d, 0xce, 0xc9, 0x60, 0x13, 0x2a,
-       0x30, 0xc5, 0xe9, 0x74, 0x2f, 0x51, 0x14, 0x3f,
-       0xdd, 0xdf, 0xca, 0x6c, 0x01, 0x73, 0x50, 0x37,
-       0x15, 0xd7, 0x8a, 0xfe, 0x70, 0x06, 0x4b, 0x9d,
-       0xe1, 0xf1, 0xbd, 0x88, 0xa9, 0x33, 0x7b, 0xf0,
-       0x2a, 0x0b, 0x3f, 0x3a, 0x8f, 0x75, 0x1a, 0xeb,
-       0xcb, 0x42, 0xfe, 0x54, 0xff, 0x5a, 0x7f, 0x78,
-       0x6a, 0x16, 0x18, 0x3d, 0x88, 0x71, 0x5e, 0xf1,
-       0x68, 0x46, 0x8a, 0xfc, 0xf6, 0xc6, 0xb5, 0xea,
-       0x9d, 0x09, 0x7b, 0xe5, 0xa9, 0x91, 0x7c, 0x47,
-       0xbb, 0xa6, 0x21, 0x88, 0x0e, 0x2f, 0x7d, 0x26,
-       0xd3, 0x91, 0xc0, 0x74, 0x34, 0x96, 0xea, 0x5e,
-       0x7d, 0x0e, 0x65, 0x5d, 0x57, 0x73, 0xd1, 0x81,
-       0xa5, 0x7c, 0x9b, 0x76, 0x67, 0x6a, 0x9a, 0x22,
-       0xae, 0x78, 0x8d, 0x5e, 0xaf, 0xa3, 0x70, 0xbf,
-       0xc0, 0x73, 0x71, 0xb1, 0x5c, 0x32, 0x58, 0xfd,
-       0xec, 0x54, 0x37, 0xb6, 0x62, 0x6a, 0x61, 0xab,
-       0x75, 0x2a, 0xa1, 0x91, 0xee, 0xd8, 0x04, 0xa2,
-       0x24, 0x53, 0x18, 0x2d, 0xf7, 0x6a, 0xf3, 0x9d,
-       0x30, 0xed, 0x20, 0xc5, 0xf4, 0x25, 0xec, 0xfb,
-       0x09, 0x98, 0x43, 0x62, 0x86, 0x37, 0xa3, 0xdb,
-       0xb3, 0x71, 0x62, 0x05, 0xd6, 0x76, 0x07, 0x98,
-       0x27, 0xf2, 0x13, 0x40, 0xad, 0x9e, 0x66, 0xb0,
-       0x79, 0x1c, 0x58, 0x62, 0x2f, 0xae, 0x72, 0x53,
-       0x4b, 0xce, 0xe9, 0x01, 0x4b, 0x71, 0xbc, 0xf2,
-       0x54, 0xa2, 0x6e, 0xf8, 0xde, 0x84, 0x9b, 0x7d,
-       0xc1, 0xef, 0xff, 0x36, 0x4d, 0x82, 0xfd, 0xd7,
-       0x96, 0xc1, 0xeb, 0xe9, 0x8a, 0x3e, 0x00, 0xf4,
-       0xdd, 0x8b, 0xd7, 0xed, 0x3d, 0x5d, 0xba, 0xcb,
-       0xad, 0xf0, 0xba, 0x8d, 0xbe, 0x7b, 0x9e, 0xfa,
-       0x02, 0x5d, 0xb3, 0x96, 0xce, 0x62, 0x5f, 0x40,
-       0x75, 0xde, 0xad, 0xa3, 0xdb, 0x6a, 0xa3, 0x16,
-       0xa0, 0x56, 0xde, 0xf8, 0x1b, 0x0c, 0x8d, 0x60,
-       0xa1, 0x8d, 0x41, 0x33, 0x86, 0x8d, 0xb2, 0xf5,
-       0x5c, 0x5d, 0xa4, 0x0b, 0x12, 0xf3, 0x40, 0xd6,
-       0x07, 0x75, 0xf9, 0xfb, 0x30, 0xa6, 0x75, 0x67,
-       0x17, 0x98, 0x16, 0x12, 0xcf, 0x53, 0x98, 0xd6,
-       0x88, 0x5c, 0x49, 0x0a, 0x7d, 0xf1, 0x0f, 0xf1,
-       0xca, 0xef, 0xe3, 0xcc, 0x6f, 0x53, 0xc1, 0xdd,
-       0xba, 0xc1, 0x03, 0x5d, 0x60, 0xd8, 0x45, 0x27,
-       0x7a, 0x5a, 0x0a, 0x8b, 0x21, 0xb2, 0xb3, 0xa4,
-       0x5d, 0x9f, 0x67, 0xd8, 0xe4, 0xfa, 0xa8, 0xc2,
-       0xef, 0x66, 0x54, 0x63, 0xad, 0x1b, 0x57, 0x6f,
-       0x1e, 0x45, 0xef, 0x77, 0x9f, 0xab, 0x60, 0x6f,
-       0x48, 0xfd, 0x8d, 0xa2, 0x3f, 0xea, 0x66, 0xf2,
-       0x9f, 0x66, 0x6f, 0xca, 0x6e, 0x7b, 0x63, 0x4b,
-       0xe5, 0xaf, 0x21, 0x0a, 0xa7, 0xbd, 0x9f, 0xe2,
-       0x75, 0xdb, 0x1b, 0x6d, 0x79, 0x77, 0xeb, 0xcc,
-       0x98, 0xdf, 0x20, 0x96, 0xc6, 0xc0, 0xce, 0x27,
-       0x35, 0x56, 0x93, 0x0c, 0x97, 0xa2, 0xaf, 0x73,
-       0xb3, 0xf7, 0xb3, 0x9e, 0xde, 0xd8, 0xa5, 0x73,
-       0x7d, 0xe4, 0x3a, 0xea, 0x62, 0x52, 0xf6, 0xe2,
-       0x4a, 0x1b, 0x65, 0xb4, 0x99, 0x35, 0x69, 0x0c,
-       0x7f, 0x9a, 0xe1, 0x2e, 0x0a, 0x49, 0x60, 0xf3,
-       0xe7, 0x0f, 0x3e, 0xf2, 0x08, 0x7d, 0x9b, 0x40,
-       0xc8, 0x01, 0xe3, 0x99, 0xee, 0x8b, 0xfc, 0x5c,
-       0xd5, 0x4b, 0x95, 0x6a, 0x8e, 0xde, 0x8b, 0x94,
-       0x3f, 0x93, 0xbd, 0x77, 0xba, 0x4b, 0x67, 0xc6,
-       0x9f, 0x65, 0x7a, 0x17, 0x14, 0xc1, 0x26, 0xbc,
-       0xf6, 0xc2, 0x66, 0xbc, 0x82, 0x4e, 0x8f, 0x57,
-       0xab, 0x6e, 0xd0, 0x7a, 0x2f, 0xe8, 0xd8, 0x5e,
-       0x66, 0x33, 0xa3, 0x9e, 0x14, 0xed, 0xb1, 0xdd,
-       0xcd, 0x1a, 0xc5, 0x84, 0x50, 0xd0, 0x9d, 0x9c,
-       0xde, 0x95, 0xbd, 0x16, 0x9e, 0x64, 0x5f, 0x3b,
-       0xc9, 0x3e, 0xca, 0xca, 0x18, 0x4b, 0x6b, 0x2a,
-       0x28, 0x86, 0xcb, 0xa2, 0xb1, 0xa0, 0x58, 0x97,
-       0xbd, 0xd3, 0x83, 0x1a, 0xd3, 0xef, 0xec, 0xd2,
-       0xc1, 0x72, 0x63, 0x18, 0xaf, 0x18, 0xb3, 0xf6,
-       0x18, 0xab, 0xc1, 0xae, 0x2e, 0xdd, 0xbe, 0xe5,
-       0xc4, 0xb3, 0x6f, 0x97, 0x1a, 0x2b, 0xc0, 0x07,
-       0x15, 0xf4, 0xfe, 0xdc, 0x3a, 0xcf, 0x74, 0x37,
-       0x6c, 0xc4, 0x52, 0x9e, 0xa5, 0x7d, 0x9e, 0x3a,
-       0xb6, 0xe7, 0xe4, 0x8d, 0xd7, 0xf3, 0xe0, 0x5c,
-       0x45, 0xd8, 0x4d, 0xfb, 0x80, 0xb7, 0x78, 0xf7,
-       0x77, 0x45, 0x21, 0xec, 0x46, 0x0e, 0xb6, 0x5f,
-       0xe3, 0x8d, 0x56, 0xac, 0xaf, 0x19, 0xbd, 0x45,
-       0x31, 0xd8, 0x44, 0xe3, 0x07, 0xde, 0x73, 0xde,
-       0x70, 0x17, 0xe8, 0x58, 0x6b, 0x6c, 0x54, 0x50,
-       0xae, 0x19, 0x90, 0x13, 0x6d, 0xc9, 0x98, 0x29,
-       0xc1, 0xff, 0x60, 0x67, 0xe0, 0xfb, 0x52, 0x6d,
-       0xb6, 0x1e, 0x07, 0xe8, 0xd8, 0xbd, 0x8a, 0x54,
-       0xc4, 0xd3, 0x46, 0x57, 0x83, 0x4e, 0xb4, 0xb1,
-       0x7d, 0x9b, 0x69, 0x4b, 0xe1, 0xda, 0x1e, 0xf6,
-       0x95, 0x2e, 0x3a, 0xcf, 0x53, 0x54, 0x4c, 0x74,
-       0xda, 0x87, 0xba, 0x83, 0x93, 0xce, 0xd1, 0x38,
-       0xcd, 0x28, 0x1f, 0xc8, 0xec, 0xeb, 0x90, 0x8c,
-       0xf2, 0x53, 0x46, 0x59, 0x24, 0x9b, 0x6d, 0x7b,
-       0xe1, 0x11, 0x11, 0xf4, 0x74, 0x6e, 0xa5, 0x55,
-       0xa6, 0x6f, 0xa1, 0x98, 0xa9, 0x74, 0x8a, 0xc9,
-       0xbf, 0x8a, 0x95, 0xb2, 0x18, 0x46, 0x30, 0xaa,
-       0x8e, 0x53, 0x6b, 0x34, 0xea, 0x1c, 0xb9, 0x9a,
-       0x95, 0xf6, 0x3b, 0x8a, 0x95, 0x71, 0x6e, 0xe5,
-       0x92, 0x83, 0x0e, 0xa6, 0xd7, 0xbd, 0xde, 0x7d,
-       0x6c, 0x27, 0xa8, 0x5d, 0x31, 0xbd, 0x41, 0xd6,
-       0xba, 0x25, 0x95, 0x78, 0x9f, 0xa4, 0x7b, 0x16,
-       0x6f, 0xb4, 0xad, 0x48, 0x3c, 0x63, 0x69, 0xb2,
-       0xfe, 0xe2, 0xa9, 0x2c, 0xda, 0xbf, 0x52, 0x3a,
-       0xff, 0x9b, 0x6f, 0x3d, 0x55, 0xf7, 0xf8, 0xbc,
-       0xb7, 0xa2, 0xf4, 0x05, 0x90, 0x4a, 0xb9, 0x4e,
-       0x95, 0x9a, 0xca, 0x6c, 0x66, 0xab, 0xe2, 0xad,
-       0xf9, 0x0f, 0x49, 0xff, 0xce, 0xcd, 0xa4, 0x57,
-       0xc9, 0x99, 0x41, 0xfd, 0x97, 0x2c, 0xc9, 0xdc,
-       0x9b, 0xf3, 0xde, 0x54, 0xae, 0x6e, 0x39, 0x69,
-       0xdd, 0xdc, 0x66, 0xa3, 0x7b, 0x04, 0x35, 0x3a,
-       0x03, 0x95, 0xf1, 0x49, 0xd2, 0x2b, 0x52, 0xef,
-       0x91, 0x4d, 0xb5, 0xac, 0xcc, 0x18, 0x2e, 0x94,
-       0x4d, 0xf3, 0xb5, 0x70, 0x91, 0x6c, 0xf1, 0xb0,
-       0xb0, 0xca, 0x67, 0x93, 0x53, 0x50, 0xcb, 0x36,
-       0xb2, 0x32, 0xc5, 0x6c, 0x54, 0x43, 0x48, 0x1f,
-       0x4d, 0x74, 0x33, 0x70, 0xba, 0x69, 0x88, 0x2e,
-       0xc4, 0x5a, 0x65, 0x8b, 0xda, 0x2a, 0x5b, 0xd8,
-       0xa9, 0xa4, 0x36, 0x95, 0x7b, 0x8b, 0xda, 0x82,
-       0x44, 0x1d, 0x23, 0xa7, 0xf2, 0x3a, 0xa4, 0xdf,
-       0x16, 0x32, 0xa5, 0xef, 0xa3, 0xfb, 0x4f, 0x6a,
-       0xae, 0xe5, 0x72, 0x32, 0xe3, 0x7a, 0x5d, 0xbf,
-       0x0a, 0x46, 0x11, 0x44, 0xda, 0x43, 0x74, 0x0a,
-       0x64, 0xc2, 0x3a, 0x0c, 0xdd, 0x29, 0x9b, 0xca,
-       0x99, 0x45, 0x62, 0x38, 0x45, 0x0d, 0x3f, 0x85,
-       0xe1, 0x6a, 0xd9, 0xcb, 0xc2, 0xdf, 0x91, 0x33,
-       0xf3, 0x08, 0x6e, 0x6d, 0xd3, 0xfc, 0xd3, 0x16,
-       0x9e, 0x0f, 0x9d, 0x76, 0xfd, 0xc6, 0x33, 0xc1,
-       0xc4, 0xf4, 0x13, 0x74, 0xdf, 0x4b, 0x1c, 0xcb,
-       0x6a, 0xba, 0x75, 0x78, 0x5c, 0xc6, 0x2f, 0x29,
-       0x0e, 0xa5, 0xe5, 0xcb, 0xf6, 0x12, 0xfe, 0xb5,
-       0xd3, 0xd1, 0xa0, 0x57, 0x8c, 0x9e, 0xd1, 0xa2,
-       0xd9, 0x33, 0x9a, 0xbd, 0xf1, 0xf8, 0xa0, 0x08,
-       0x7f, 0x3c, 0x33, 0x66, 0x10, 0x98, 0x9f, 0xc0,
-       0x7e, 0x65, 0x86, 0x67, 0xd8, 0x9b, 0xf4, 0x4f,
-       0x73, 0xda, 0xcc, 0xbf, 0x66, 0x9e, 0xef, 0x3b,
-       0xcc, 0x62, 0x36, 0xd1, 0x6e, 0x3c, 0xe3, 0x91,
-       0xe9, 0x5d, 0x3a, 0x01, 0x9e, 0x66, 0x9e, 0x76,
-       0x70, 0x7a, 0xd7, 0x5a, 0x80, 0xa7, 0x69, 0xc4,
-       0x79, 0xfd, 0x9a, 0x04, 0x91, 0x0d, 0x3c, 0xff,
-       0x02, 0xd6, 0xfb, 0x6a, 0x3c, 0xc2, 0x6d, 0x74,
-       0x8a, 0xed, 0xa1, 0x07, 0xe9, 0xcd, 0x34, 0x69,
-       0x31, 0xea, 0xa4, 0x1f, 0x43, 0x16, 0x89, 0xde,
-       0x5a, 0xda, 0xf6, 0x93, 0x31, 0xc8, 0xbf, 0x98,
-       0x7d, 0x19, 0x0b, 0xb5, 0x4d, 0x67, 0x03, 0x1e,
-       0x7a, 0x82, 0xd1, 0xef, 0x44, 0x3a, 0xdb, 0x6b,
-       0xf2, 0xc6, 0x16, 0x46, 0x5d, 0xc1, 0xa8, 0xf7,
-       0x20, 0x35, 0x9b, 0xf7, 0x6a, 0x46, 0x15, 0xe9,
-       0xce, 0xc0, 0x1b, 0x9b, 0xab, 0xf0, 0x2a, 0x5c,
-       0xd6, 0xde, 0xf6, 0xb3, 0x85, 0x71, 0x44, 0xd3,
-       0x21, 0xa7, 0x9e, 0xee, 0xf7, 0x7b, 0x5a, 0x42,
-       0x81, 0x56, 0xa9, 0xad, 0x43, 0xfb, 0x7a, 0xa0,
-       0x30, 0x4d, 0xb0, 0x40, 0x75, 0x4b, 0x43, 0xa8,
-       0x33, 0xd8, 0x24, 0x3c, 0xdc, 0xd2, 0x18, 0x6a,
-       0x16, 0x90, 0x14, 0xa3, 0x34, 0x37, 0xb5, 0x28,
-       0xcd, 0xa1, 0x78, 0x4a, 0x63, 0x53, 0x40, 0xe5,
-       0xc1, 0x3f, 0x55, 0x03, 0xa0, 0x13, 0x24, 0xd0,
-       0xcf, 0x90, 0xc0, 0x90, 0xee, 0xbe, 0xa8, 0x13,
-       0x04, 0x76, 0x92, 0x35, 0x5d, 0x75, 0x3d, 0xf4,
-       0x2c, 0x4e, 0xb7, 0x31, 0x98, 0xc0, 0xde, 0x23,
-       0x1f, 0x74, 0x5f, 0x05, 0x9b, 0x6a, 0xd5, 0x86,
-       0x80, 0x2e, 0x08, 0x19, 0xb7, 0xd1, 0x1b, 0x59,
-       0x7e, 0x37, 0x9d, 0x60, 0x2a, 0x90, 0xc7, 0x8c,
-       0xc4, 0xd1, 0xdf, 0xe6, 0xf4, 0x34, 0xd6, 0x17,
-       0x28, 0x65, 0x00, 0x82, 0xb0, 0xd2, 0x10, 0x1a,
-       0x73, 0x66, 0x44, 0xa3, 0x3e, 0x94, 0x22, 0x61,
-       0xae, 0xc8, 0x71, 0x24, 0xda, 0xcf, 0x53, 0xde,
-       0x10, 0xab, 0x1f, 0x16, 0x6b, 0x09, 0x42, 0xc8,
-       0x86, 0x52, 0x2f, 0x04, 0xac, 0x41, 0xb6, 0xbb,
-       0x89, 0x46, 0x03, 0x78, 0x01, 0xe9, 0xba, 0xd0,
-       0x68, 0x0c, 0x1d, 0x43, 0xba, 0x8e, 0xd1, 0xb7,
-       0xa8, 0x9e, 0xc0, 0xc4, 0xb0, 0xad, 0x18, 0x17,
-       0x46, 0x2e, 0x7d, 0x68, 0x24, 0x86, 0x5e, 0x0e,
-       0x8d, 0x51, 0x7d, 0xa5, 0x3e, 0x34, 0x1a, 0xa9,
-       0x06, 0xa4, 0x6d, 0x55, 0x69, 0x4f, 0x21, 0x2d,
-       0x19, 0xa5, 0x10, 0x6d, 0x7d, 0x60, 0x54, 0x50,
-       0xcf, 0x5b, 0x1c, 0xb1, 0x95, 0xfc, 0x2d, 0x8d,
-       0x4c, 0xfd, 0xca, 0xc4, 0x73, 0x7f, 0x9f, 0x61,
-       0xa0, 0x77, 0x21, 0xa5, 0x7a, 0xbf, 0x0b, 0x4b,
-       0x77, 0x49, 0x7b, 0x83, 0x82, 0xc5, 0x1a, 0xce,
-       0xdd, 0x5f, 0xc0, 0x63, 0x4b, 0x6f, 0x8c, 0x5d,
-       0x3f, 0x68, 0xe8, 0x2b, 0x30, 0x48, 0x59, 0x7e,
-       0x97, 0xa7, 0xc4, 0x5b, 0xb2, 0x7e, 0x10, 0x1a,
-       0x11, 0x1b, 0x17, 0xc3, 0x2c, 0x88, 0x25, 0xfb,
-       0x5d, 0xde, 0x12, 0x84, 0xa6, 0x58, 0xba, 0x88,
-       0x97, 0xde, 0xa1, 0x16, 0xdf, 0xdd, 0x47, 0x5a,
-       0xdf, 0x97, 0xb7, 0xd2, 0x58, 0x08, 0x67, 0x66,
-       0xf7, 0xbe, 0x91, 0x96, 0x2b, 0x00, 0xdf, 0x59,
-       0xae, 0x98, 0xfb, 0x66, 0xef, 0x2f, 0x86, 0x7e,
-       0xd1, 0x88, 0xd7, 0x51, 0xeb, 0x4a, 0x6c, 0x6b,
-       0x71, 0xe6, 0x63, 0x2b, 0x39, 0x07, 0xa9, 0x98,
-       0xff, 0x89, 0xca, 0x53, 0x06, 0x94, 0x73, 0xda,
-       0x15, 0x39, 0x1d, 0xc6, 0x7f, 0xf8, 0x17, 0xc1,
-       0x7f, 0xa7, 0x9f, 0x7b, 0x2e, 0x0c, 0xcf, 0xb9,
-       0x04, 0x21, 0x1c, 0x0e, 0x0b, 0xcf, 0xe1, 0x5f,
-       0xf8, 0xb9, 0x70, 0x98, 0xd3, 0x4e, 0x8b, 0xc8,
-       0xe3, 0x22, 0xbe, 0xf0, 0x73, 0x91, 0xc8, 0x73,
-       0xa7, 0x89, 0x16, 0x16, 0x5c, 0x02, 0xb2, 0x08,
-       0x9c, 0xef, 0x34, 0xf2, 0x11, 0x07, 0x13, 0x29,
-       0x3c, 0x47, 0xf2, 0x30, 0xed, 0x69, 0x30, 0xdf,
-       0x4b, 0xdf, 0x0d, 0x3a, 0xad, 0x63, 0x73, 0x8c,
-       0x23, 0xe6, 0x1c, 0xfa, 0x36, 0x0b, 0x0b, 0xff,
-       0x7c, 0x35, 0xb7, 0xb2, 0xb7, 0x15, 0xfd, 0x6a,
-       0x9d, 0x33, 0x07, 0x2c, 0x79, 0x70, 0xba, 0x82,
-       0x4e, 0xa2, 0x2d, 0x80, 0xcd, 0xd4, 0xbb, 0x0f,
-       0xe1, 0xdc, 0xe2, 0x91, 0xe5, 0xe3, 0x10, 0xc3,
-       0x91, 0x91, 0x53, 0xce, 0xd7, 0xff, 0x0b, 0xc1,
-       0x08, 0x7b, 0x4b, 0xfb, 0x90, 0xe8, 0xdc, 0xd5,
-       0x15, 0x5d, 0xdb, 0x86, 0x1c, 0xc7, 0x3e, 0x8f,
-       0x23, 0x79, 0x38, 0x5e, 0xa0, 0x63, 0x5c, 0x87,
-       0x55, 0xc9, 0xba, 0x98, 0xe4, 0xc3, 0x2a, 0xdf,
-       0x7e, 0xe6, 0x73, 0x0e, 0xc7, 0x24, 0xeb, 0x8e,
-       0x7d, 0x1e, 0x47, 0xf2, 0x70, 0x9c, 0xbe, 0x1c,
-       0xc3, 0xdf, 0x3c, 0xf7, 0xb9, 0x96, 0x9a, 0x3d,
-       0xfc, 0x3d, 0xf2, 0x08, 0x8e, 0xc8, 0xfd, 0xcb,
-       0x2d, 0x38, 0x22, 0xff, 0x96, 0xe3, 0x25, 0x57,
-       0x41, 0xe5, 0x62, 0x16, 0xb4, 0x5f, 0x1a, 0x9b,
-       0x4e, 0x36, 0xdc, 0x13, 0x4f, 0xeb, 0xed, 0x82,
-       0x6c, 0x7a, 0x43, 0x01, 0xe1, 0xaa, 0x33, 0xde,
-       0x46, 0xf4, 0x83, 0x63, 0x5c, 0xa0, 0x73, 0xea,
-       0x49, 0x2a, 0xf3, 0x7a, 0xfb, 0x7b, 0x68, 0xa6,
-       0x40, 0x52, 0xa3, 0xfc, 0x6d, 0x75, 0xe4, 0xcc,
-       0x62, 0x34, 0xe3, 0xba, 0x62, 0x30, 0xa6, 0x84,
-       0x11, 0xb7, 0xc7, 0x70, 0x3d, 0xa6, 0x36, 0x8f,
-       0x71, 0x43, 0x12, 0xbf, 0xfb, 0x87, 0x3e, 0x2f,
-       0x43, 0x67, 0xc4, 0xbe, 0xec, 0xc2, 0x5e, 0x35,
-       0x8a, 0xf7, 0x5d, 0x9a, 0xc9, 0xc0, 0xd3, 0xe5,
-       0xbc, 0xc7, 0xe3, 0xbc, 0x26, 0x2c, 0x70, 0x1f,
-       0xf7, 0x46, 0x2f, 0x95, 0x17, 0x67, 0x36, 0xff,
-       0x2a, 0xd8, 0x84, 0x77, 0xd3, 0x23, 0xfc, 0xdd,
-       0x01, 0x03, 0xbf, 0x07, 0x68, 0xfe, 0xb2, 0xab,
-       0x2e, 0x9d, 0x4b, 0xf7, 0x1f, 0x5c, 0xaf, 0x39,
-       0xc3, 0xea, 0xba, 0xed, 0xab, 0xa5, 0xeb, 0x7f,
-       0x8b, 0xbf, 0xaf, 0xda, 0xeb, 0xbf, 0xd7, 0x9f,
-       0xf6, 0x5d, 0xbd, 0x9e, 0x36, 0xfa, 0x5a, 0xe6,
-       0x3f, 0x5d, 0x60, 0xde, 0x78, 0xb3, 0x9c, 0xec,
-       0x1e, 0xa0, 0x11, 0xff, 0x47, 0x2f, 0xf1, 0xd9,
-       0x06, 0x5f, 0x63, 0xaa, 0x5f, 0xcd, 0x8c, 0x4a,
-       0xf0, 0x2f, 0x0f, 0xe6, 0x80, 0x02, 0x7a, 0x6b,
-       0xfe, 0x20, 0xae, 0x4e, 0xf9, 0x17, 0xdc, 0xb7,
-       0xbd, 0xf9, 0x1c, 0xff, 0x0e, 0x38, 0xfa, 0xa4,
-       0xca, 0x33, 0xde, 0x1a, 0x57, 0x9e, 0xb6, 0x1f,
-       0x03, 0x69, 0xec, 0x8b, 0x8b, 0x38, 0x26, 0x7b,
-       0x77, 0x20, 0x2c, 0x62, 0x57, 0x2f, 0x9f, 0xd9,
-       0x8c, 0x76, 0x81, 0x2b, 0x3d, 0x31, 0xa3, 0x98,
-       0xb8, 0xe8, 0xac, 0x2d, 0xa0, 0xbd, 0x0c, 0xbb,
-       0xd5, 0x51, 0xb8, 0x91, 0xa7, 0x16, 0x06, 0x4b,
-       0xdc, 0x73, 0x66, 0xb1, 0x79, 0x87, 0x91, 0xae,
-       0x66, 0xd0, 0x52, 0xac, 0xb0, 0x22, 0x77, 0xb7,
-       0xb6, 0xba, 0x90, 0x0b, 0x98, 0xc7, 0x6a, 0xa3,
-       0x93, 0xbd, 0x04, 0x5a, 0xf7, 0xb3, 0x9d, 0xfb,
-       0x78, 0xb5, 0xb1, 0x70, 0x2a, 0x58, 0xf1, 0x6a,
-       0x07, 0x1b, 0x5e, 0xc7, 0x41, 0xaa, 0xb7, 0x0f,
-       0x4b, 0x41, 0xfb, 0x7d, 0xf8, 0xe8, 0x9e, 0x85,
-       0x52, 0x4c, 0x4c, 0x8a, 0x70, 0x7d, 0x7e, 0x10,
-       0x1e, 0x96, 0x9f, 0x9d, 0x97, 0x4a, 0x9d, 0x99,
-       0xe9, 0x3e, 0x68, 0x41, 0xfe, 0x39, 0xee, 0xea,
-       0x02, 0xdd, 0x4f, 0x07, 0x31, 0xdf, 0xfd, 0x53,
-       0x13, 0x49, 0xa7, 0x7f, 0xb7, 0x84, 0xde, 0x62,
-       0xfd, 0xfb, 0x25, 0x6b, 0xa0, 0x86, 0xd6, 0xb2,
-       0xb8, 0x52, 0x3b, 0xed, 0xfd, 0x89, 0xab, 0xd7,
-       0x55, 0x90, 0x0b, 0x50, 0x98, 0x07, 0x50, 0xac,
-       0x3f, 0x82, 0x33, 0x81, 0x73, 0x55, 0x4e, 0x03,
-       0xed, 0x50, 0x7e, 0xc2, 0x35, 0x4d, 0x7f, 0x18,
-       0xc7, 0x09, 0x86, 0xf5, 0xf7, 0x79, 0x37, 0xb8,
-       0x8a, 0xf4, 0x7d, 0x95, 0x87, 0x18, 0xe5, 0xb4,
-       0x97, 0x38, 0xba, 0x5d, 0xb6, 0x03, 0xb6, 0x9f,
-       0xda, 0x0e, 0xfa, 0x67, 0xa1, 0x07, 0xee, 0xc9,
-       0x99, 0x20, 0x0c, 0x7a, 0xe6, 0x96, 0x2e, 0xd2,
-       0xf4, 0xfa, 0x91, 0x37, 0x42, 0x35, 0x6f, 0x8d,
-       0xec, 0x13, 0x22, 0x31, 0x6d, 0x9a, 0x9f, 0x5e,
-       0x27, 0xc1, 0xbf, 0x2e, 0x45, 0x1e, 0x27, 0xe3,
-       0x79, 0xe2, 0x3b, 0x6f, 0xd6, 0x94, 0x71, 0x0d,
-       0x15, 0xf3, 0xd9, 0x6a, 0x79, 0x86, 0xfd, 0xd8,
-       0xe3, 0xe9, 0x89, 0x99, 0x38, 0xbb, 0xfc, 0x57,
-       0xcf, 0xbc, 0xb7, 0xa3, 0x97, 0x70, 0x66, 0xe0,
-       0x38, 0x4a, 0x1c, 0x7b, 0xe7, 0xfd, 0x3c, 0xfa,
-       0x5e, 0x7a, 0x62, 0xc8, 0xb8, 0x02, 0x5b, 0xfb,
-       0xc4, 0x21, 0x61, 0x96, 0xe0, 0xc0, 0x39, 0x43,
-       0x78, 0x52, 0x84, 0x24, 0xc7, 0xb4, 0x41, 0xe9,
-       0x2c, 0xf4, 0x95, 0xd4, 0x7f, 0x59, 0xc1, 0xe7,
-       0xc6, 0xe5, 0x83, 0x02, 0x70, 0x8b, 0x19, 0xfa,
-       0x5a, 0x79, 0x75, 0xfc, 0xc7, 0xca, 0xa1, 0x7c,
-       0xae, 0x7f, 0x0e, 0xd9, 0x5d, 0x45, 0xa5, 0x67,
-       0x8e, 0xbb, 0xaa, 0x6a, 0x2e, 0x06, 0xc7, 0x95,
-       0xb7, 0xb4, 0xe2, 0xec, 0x34, 0xd8, 0x12, 0x0a,
-       0x35, 0xb1, 0x0f, 0x57, 0x7b, 0xfd, 0xb5, 0xcb,
-       0xdb, 0xdb, 0x84, 0x15, 0x79, 0x39, 0xf9, 0x79,
-       0x9e, 0x39, 0x74, 0xfc, 0x28, 0xb6, 0xdd, 0xb0,
-       0xbf, 0xec, 0x6c, 0xf5, 0xcc, 0x86, 0x08, 0x7b,
-       0x5b, 0x61, 0xa2, 0xe2, 0xc7, 0x19, 0x7a, 0x06,
-       0x7b, 0xb6, 0x8d, 0x3a, 0x77, 0x16, 0xeb, 0x21,
-       0x98, 0x88, 0x2b, 0x5d, 0x53, 0xc9, 0x45, 0x5d,
-       0x38, 0x34, 0xc1, 0xc9, 0x9e, 0x8d, 0xf7, 0xe2,
-       0xaa, 0x1a, 0x75, 0x47, 0x4f, 0xe6, 0xb0, 0x75,
-       0x02, 0x5f, 0xc0, 0xc1, 0xc7, 0x47, 0xed, 0xb9,
-       0x6b, 0x2c, 0x8f, 0xda, 0x9b, 0xa5, 0x44, 0x2b,
-       0xbf, 0x4e, 0xf6, 0x8d, 0xf9, 0x0f, 0xe7, 0xa1,
-       0xf7, 0xc2, 0xb7, 0x78, 0x75, 0x56, 0x76, 0x0f,
-       0xc1, 0xc4, 0x73, 0xe1, 0x3a, 0xa3, 0xf7, 0xfa,
-       0x03, 0x3a, 0x3a, 0x8d, 0x6b, 0xa6, 0xb3, 0xb1,
-       0x2a, 0x40, 0x6f, 0x9c, 0x98, 0x70, 0xf6, 0xd0,
-       0xac, 0x78, 0xf0, 0xda, 0xa5, 0x14, 0x53, 0xdb,
-       0xbd, 0x35, 0x5e, 0x82, 0x5d, 0x69, 0xb4, 0x1e,
-       0xf8, 0x31, 0xdb, 0x9d, 0xf1, 0x16, 0xce, 0xcd,
-       0x77, 0x99, 0x22, 0x5d, 0xa3, 0xa2, 0x67, 0xd9,
-       0x17, 0x55, 0x72, 0x9c, 0x12, 0x28, 0x2b, 0x05,
-       0x97, 0x2f, 0x2c, 0xb3, 0x3d, 0x05, 0x6f, 0xa5,
-       0x4b, 0xf0, 0x83, 0x8f, 0xa4, 0x4c, 0xfe, 0xfe,
-       0x39, 0x7d, 0x9e, 0xa3, 0xb3, 0xad, 0xb1, 0x49,
-       0x6e, 0x69, 0x6b, 0x6a, 0x14, 0x9a, 0xda, 0x42,
-       0xc1, 0x55, 0x42, 0x4b, 0x5b, 0xa8, 0x5d, 0xf0,
-       0x06, 0x43, 0x73, 0xda, 0xdb, 0xd8, 0x7e, 0x93,
-       0xb7, 0xbc, 0x22, 0xfc, 0x60, 0x97, 0x05, 0xe8,
-       0xdd, 0x12, 0x28, 0x56, 0xc0, 0x98, 0xac, 0xf9,
-       0x88, 0x97, 0x7c, 0xbe, 0xd1, 0x99, 0x49, 0x0a,
-       0x7c, 0xff, 0x20, 0xfa, 0x8b, 0x80, 0x0c, 0xdf,
-       0xef, 0xa1, 0xaf, 0xe9, 0xf6, 0xc8, 0x48, 0x79,
-       0x01, 0x57, 0x07, 0x03, 0xdc, 0x4b, 0x08, 0x25,
-       0x19, 0xab, 0x28, 0x65, 0xd5, 0x8b, 0x90, 0x91,
-       0x05, 0x4a, 0xb2, 0x50, 0x92, 0x5e, 0x1a, 0xa3,
-       0x98, 0xb9, 0x9d, 0xf8, 0xbe, 0x29, 0xb3, 0x67,
-       0x9f, 0xef, 0x7c, 0x8a, 0xa5, 0xf3, 0xf2, 0xda,
-       0x13, 0xde, 0x8b, 0x2b, 0x83, 0x1f, 0x14, 0x09,
-       0x25, 0x78, 0x65, 0x5f, 0x72, 0xe8, 0xc5, 0xda,
-       0xfd, 0xc0, 0x21, 0x18, 0x69, 0x4d, 0xf5, 0x63,
-       0xf6, 0xe5, 0xd9, 0xde, 0x1c, 0xa4, 0xa4, 0x09,
-       0x09, 0x12, 0xbc, 0xc6, 0xea, 0xdf, 0x5b, 0x84,
-       0xb8, 0x89, 0xf0, 0x1f, 0xbb, 0xb8, 0x1c, 0xad,
-       0xdc, 0x86, 0x05, 0x5a, 0xb9, 0xbf, 0xbf, 0x89,
-       0x7c, 0xdb, 0xf7, 0x71, 0x7d, 0xf0, 0x4f, 0xaf,
-       0xc9, 0xf0, 0xe2, 0x00, 0x95, 0xfa, 0x9f, 0x7a,
-       0x30, 0xd4, 0xbf, 0xf1, 0xb1, 0x76, 0x78, 0xf1,
-       0x3c, 0x96, 0x7d, 0x86, 0x5a, 0xf6, 0x8a, 0xb8,
-       0xb2, 0x5a, 0xd5, 0xb2, 0x86, 0x51, 0x96, 0x4d,
-       0x24, 0x97, 0xf5, 0x71, 0xff, 0x69, 0x55, 0xba,
-       0x0f, 0xd3, 0x58, 0xf0, 0x67, 0x62, 0x27, 0xab,
-       0x95, 0x6f, 0xee, 0x02, 0x43, 0xa1, 0xfe, 0xe0,
-       0x20, 0xcc, 0xe3, 0x27, 0x02, 0x3d, 0xfb, 0x46,
-       0xc6, 0xdc, 0x1a, 0x4f, 0x60, 0x6e, 0x2a, 0xf3,
-       0x81, 0xa9, 0x38, 0x7f, 0x47, 0x0b, 0xb8, 0x24,
-       0x18, 0xa8, 0xc4, 0x47, 0xf6, 0xa4, 0xcf, 0x1d,
-       0xca, 0xe3, 0xfd, 0x37, 0xf8, 0x5b, 0xe9, 0x41,
-       0x69, 0xf9, 0xb4, 0xe6, 0x60, 0x08, 0xed, 0x7e,
-       0x4a, 0x47, 0x43, 0xb0, 0xa9, 0xa9, 0x2d, 0x27,
-       0xb4, 0x32, 0xc4, 0x9e, 0x68, 0x53, 0x5d, 0xf4,
-       0x1b, 0x70, 0x05, 0x46, 0x77, 0x2b, 0xb6, 0x81,
-       0x83, 0x9d, 0x93, 0xf3, 0x6d, 0x09, 0x9e, 0x4e,
-       0xf5, 0xae, 0x8c, 0x46, 0x33, 0x5c, 0x55, 0xe7,
-       0xd1, 0x4b, 0x69, 0x7c, 0xf5, 0xc8, 0x17, 0x1c,
-       0xce, 0xf7, 0xb7, 0xf4, 0x96, 0x9f, 0x8e, 0xbe,
-       0xcf, 0xa8, 0x38, 0xe8, 0x24, 0x92, 0x19, 0x03,
-       0x79, 0x93, 0xc1, 0xb4, 0xbf, 0xab, 0x1f, 0xce,
-       0x2d, 0x4a, 0xb9, 0xcf, 0xe6, 0x2f, 0x39, 0x17,
-       0xbd, 0x3c, 0xe9, 0x4d, 0x46, 0x3f, 0x07, 0xd6,
-       0xf9, 0x6e, 0xf9, 0xaa, 0x68, 0x63, 0x7c, 0xd7,
-       0x62, 0x31, 0xd7, 0xd2, 0xc9, 0x0b, 0x26, 0xa4,
-       0xb3, 0x6f, 0x55, 0x79, 0x16, 0xe5, 0xbd, 0x4a,
-       0xd2, 0xd8, 0xf7, 0xeb, 0x8c, 0xf1, 0x5f, 0x5f,
-       0xe6, 0xfa, 0x37, 0x9b, 0xad, 0x56, 0x1b, 0x3a,
-       0xb8, 0x69, 0xa9, 0xc2, 0x12, 0x3b, 0xad, 0x22,
-       0xd5, 0xf6, 0xd0, 0xa1, 0xd5, 0xbc, 0x3c, 0x4d,
-       0x86, 0xef, 0xad, 0x26, 0xfd, 0xbf, 0xec, 0xc4,
-       0x50, 0x20, 0x0b, 0x84, 0x04, 0x61, 0x48, 0xe3,
-       0xc5, 0x22, 0xe8, 0xb6, 0xc6, 0xf8, 0x71, 0x05,
-       0xf7, 0xb2, 0x05, 0xb9, 0x7c, 0x8c, 0x1f, 0x30,
-       0xe4, 0xba, 0x8e, 0xdf, 0x45, 0x5f, 0x8a, 0x88,
-       0xf1, 0xcb, 0x12, 0xfc, 0xef, 0x13, 0xc8, 0x35,
-       0x96, 0xf8, 0xff, 0x77, 0x2f, 0x86, 0x6c, 0xd7,
-       0xf1, 0xd3, 0x17, 0x53, 0xa6, 0xc5, 0xf8, 0x0b,
-       0x91, 0xeb, 0x45, 0x19, 0x76, 0x9c, 0x67, 0xfc,
-       0xcf, 0x61, 0xe8, 0xf4, 0x75, 0xfc, 0xb4, 0x27,
-       0xd8, 0x12, 0xe3, 0x37, 0x21, 0xd7, 0x6a, 0xe4,
-       0x7a, 0x8d, 0xf1, 0xa3, 0xfd, 0xef, 0xe8, 0xb9,
-       0x8e, 0x7f, 0x89, 0x48, 0xdf, 0xcc, 0x51, 0xf9,
-       0xe1, 0x3d, 0xf7, 0x80, 0xee, 0x25, 0xab, 0x03,
-       0xbd, 0xaf, 0x45, 0x16, 0xf8, 0xaa, 0x1f, 0x5c,
-       0x61, 0xb4, 0x85, 0x77, 0x1d, 0x90, 0xe4, 0x75,
-       0xe1, 0xd5, 0xc2, 0x68, 0x1e, 0x0c, 0xe1, 0xb8,
-       0xd2, 0xe3, 0x42, 0x7e, 0x6c, 0xaf, 0x9e, 0x22,
-       0xd6, 0x9a, 0xa5, 0xf4, 0xed, 0x81, 0x3d, 0xd9,
-       0x2c, 0xec, 0xc5, 0xbe, 0x3f, 0xa0, 0xfb, 0x16,
-       0xc6, 0x8d, 0xa3, 0x9e, 0xb0, 0x07, 0x10, 0x7b,
-       0x14, 0xb1, 0x64, 0x16, 0x5b, 0x49, 0xb4, 0x1f,
-       0x5d, 0x40, 0x5a, 0x08, 0xed, 0x7a, 0x80, 0xd3,
-       0x36, 0x52, 0x29, 0xbc, 0x24, 0xe3, 0x47, 0x7d,
-       0x8c, 0x52, 0xad, 0xf8, 0x91, 0x63, 0x21, 0x72,
-       0x1c, 0x67, 0xfc, 0x7b, 0x11, 0x9b, 0x89, 0xd8,
-       0x61, 0x16, 0x5b, 0xcb, 0x68, 0x3b, 0x90, 0x86,
-       0xfe, 0xe3, 0x9f, 0x76, 0x73, 0x1a, 0x93, 0x51,
-       0xcd, 0x64, 0x3c, 0x2f, 0xa6, 0xba, 0x07, 0xc0,
-       0x23, 0x5a, 0xf0, 0xda, 0x24, 0x1a, 0xf1, 0x4a,
-       0x69, 0x9f, 0x54, 0x5b, 0xfc, 0x5e, 0x7a, 0x97,
-       0xec, 0x82, 0x4e, 0xbe, 0xc2, 0x42, 0xa7, 0xfa,
-       0x13, 0x94, 0x58, 0x28, 0x9e, 0x56, 0xd5, 0xd9,
-       0xd1, 0xd9, 0xd0, 0xd0, 0xd4, 0xd1, 0x61, 0x01,
-       0xf6, 0xe5, 0x95, 0x6c, 0x21, 0xd8, 0xd4, 0xd1,
-       0xda, 0x2e, 0x35, 0x0a, 0x72, 0x67, 0x1b, 0xff,
-       0xe4, 0x8a, 0x2c, 0xe1, 0x58, 0xd0, 0x18, 0x8b,
-       0x7f, 0xb8, 0xb9, 0x91, 0xc5, 0xb7, 0xb5, 0x87,
-       0x04, 0x09, 0x39, 0x56, 0x34, 0x09, 0xed, 0x41,
-       0xa1, 0xbd, 0xb5, 0x31, 0x16, 0xb3, 0xa2, 0x29,
-       0xd8, 0x81, 0x09, 0x2d, 0x20, 0xd3, 0x20, 0x42,
-       0x7c, 0x72, 0x3b, 0x7a, 0x38, 0xc1, 0x81, 0x7c,
-       0xad, 0x4d, 0x6d, 0x4a, 0xa8, 0x59, 0x98, 0x2e,
-       0x38, 0x27, 0xab, 0xf1, 0x77, 0xc1, 0x5d, 0x02,
-       0x25, 0x43, 0xe7, 0x87, 0x4e, 0x0f, 0xbd, 0x21,
-       0x67, 0x99, 0x9e, 0x01, 0xd3, 0x61, 0xa1, 0xb7,
-       0xb4, 0x92, 0x49, 0x74, 0x3a, 0x73, 0x9c, 0x16,
-       0x68, 0x68, 0x6e, 0x09, 0x2c, 0x6f, 0x5a, 0x2e,
-       0x08, 0x42, 0x86, 0x93, 0xfd, 0x09, 0x53, 0x28,
-       0x0c, 0x4d, 0x2b, 0x39, 0x19, 0x13, 0x4f, 0xa1,
-       0xcb, 0x74, 0xbc, 0x74, 0xb4, 0x4a, 0x58, 0x32,
-       0xa2, 0x81, 0x87, 0xef, 0xd5, 0xb9, 0x32, 0x67,
-       0x20, 0x7a, 0x65, 0x0c, 0xae, 0xcc, 0x2e, 0xbf,
-       0x96, 0x55, 0x39, 0xe9, 0xe7, 0x08, 0xf7, 0x4f,
-       0x3a, 0x84, 0xd7, 0xdd, 0x15, 0x03, 0xa9, 0x17,
-       0xb2, 0x47, 0x06, 0x52, 0xe8, 0x24, 0xa8, 0xcb,
-       0xbb, 0xd3, 0xf9, 0x37, 0x5c, 0xe8, 0xad, 0xc3,
-       0x41, 0xfe, 0x7d, 0x16, 0xea, 0xbb, 0x97, 0xf7,
-       0x66, 0x95, 0xe7, 0xdd, 0xe1, 0xd4, 0x45, 0x96,
-       0xf4, 0xd4, 0x56, 0x5c, 0x00, 0xab, 0x7c, 0xb9,
-       0x20, 0x3b, 0x7a, 0x45, 0x30, 0xf1, 0x34, 0xac,
-       0x37, 0xa3, 0x5c, 0xc5, 0xe6, 0x1c, 0x6c, 0x64,
-       0xdf, 0xa0, 0x92, 0x60, 0x42, 0xa5, 0xdf, 0x2b,
-       0x3a, 0xd8, 0xc9, 0x2a, 0x14, 0x33, 0x5e, 0x18,
-       0x0c, 0x36, 0x0a, 0x19, 0xfc, 0x1b, 0xec, 0x5e,
-       0x2f, 0xc6, 0xeb, 0xe9, 0x8b, 0x54, 0xb4, 0xdb,
-       0x6b, 0x42, 0xba, 0xdf, 0x5b, 0x72, 0x21, 0x7a,
-       0xd5, 0xf6, 0xcb, 0xa5, 0x83, 0xe6, 0x1d, 0x90,
-       0x18, 0x8d, 0x56, 0xff, 0xac, 0x48, 0x7f, 0xa8,
-       0x2b, 0x0a, 0xbe, 0x52, 0xba, 0x43, 0x37, 0xa2,
-       0x67, 0x4f, 0x57, 0x02, 0xb0, 0xd0, 0xd3, 0x7b,
-       0xba, 0x4c, 0xb1, 0x90, 0x8e, 0x87, 0x1e, 0xdc,
-       0xd3, 0xa5, 0xe7, 0xa1, 0xca, 0x3d, 0x5d, 0x06,
-       0x1e, 0x7a, 0xa6, 0x64, 0x60, 0x4c, 0x9d, 0x77,
-       0xdd, 0x31, 0x4f, 0x41, 0xae, 0x00, 0x53, 0x4d,
-       0x55, 0x3f, 0x16, 0x4a, 0xb3, 0x27, 0xf8, 0x12,
-       0xe9, 0x14, 0x62, 0xc7, 0x9c, 0xbf, 0xff, 0x94,
-       0xea, 0x2e, 0x8c, 0x64, 0x56, 0x40, 0x65, 0x13,
-       0x78, 0x2d, 0x52, 0xec, 0x4a, 0x1a, 0x3b, 0x17,
-       0xfa, 0x0a, 0x3b, 0x17, 0xba, 0x7f, 0x53, 0x31,
-       0x08, 0xa3, 0xdd, 0xd1, 0xa8, 0xf8, 0x51, 0xe5,
-       0xa9, 0xf6, 0x6b, 0xf4, 0x2e, 0x61, 0x3e, 0x3b,
-       0x0d, 0x94, 0xf6, 0xab, 0x56, 0x75, 0x3a, 0x75,
-       0x22, 0x8c, 0xf7, 0x32, 0xdd, 0xfc, 0x58, 0x82,
-       0x91, 0x9b, 0x45, 0x2c, 0xe7, 0x98, 0x41, 0xa6,
-       0x07, 0xc2, 0x1f, 0x43, 0xfc, 0x45, 0x2c, 0xc9,
-       0x73, 0xb4, 0x67, 0x6b, 0xc4, 0xf3, 0x22, 0x8c,
-       0x7c, 0xb0, 0xb5, 0x63, 0x65, 0xe0, 0xe1, 0xc6,
-       0xfa, 0x40, 0xc9, 0x80, 0xe0, 0x42, 0xda, 0x66,
-       0xfa, 0x22, 0xb2, 0xd3, 0xf4, 0x1b, 0xf6, 0xe4,
-       0xc3, 0xf6, 0x47, 0x38, 0x23, 0x81, 0xe5, 0x6c,
-       0xa8, 0xe8, 0x80, 0x5b, 0xb6, 0xf9, 0x40, 0xb1,
-       0xd6, 0x80, 0x62, 0x5e, 0x08, 0x8a, 0x71, 0x3e,
-       0xc8, 0xf2, 0xae, 0x62, 0x30, 0x2b, 0xe2, 0xea,
-       0x47, 0x0e, 0x97, 0xaf, 0xd0, 0x21, 0xcd, 0xba,
-       0x42, 0xbf, 0x08, 0x14, 0x93, 0x2f, 0x41, 0xae,
-       0x5c, 0x01, 0x4e, 0xd3, 0x45, 0x9a, 0x8d, 0xe1,
-       0x8c, 0x47, 0x87, 0xb3, 0x63, 0xeb, 0xd5, 0x1a,
-       0xc3, 0xb2, 0x02, 0x94, 0xfc, 0x0d, 0x9f, 0x41,
-       0x49, 0x0e, 0x8c, 0x8a, 0x24, 0xc8, 0xf4, 0x05,
-       0x90, 0xc6, 0xbe, 0x91, 0x62, 0x2a, 0x7d, 0x9f,
-       0xc4, 0x9c, 0x00, 0x26, 0xc5, 0x62, 0xfe, 0x29,
-       0x24, 0x96, 0x26, 0x20, 0x3e, 0x85, 0x46, 0xa9,
-       0xf1, 0xd5, 0x18, 0xfa, 0x2b, 0x7a, 0x73, 0xfa,
-       0xb3, 0xf7, 0x8a, 0xef, 0x70, 0x16, 0x9f, 0x86,
-       0x48, 0x79, 0x4f, 0x97, 0x88, 0xb3, 0xe9, 0xe8,
-       0x02, 0x67, 0xf1, 0x73, 0x88, 0xc9, 0x4e, 0xb3,
-       0x09, 0x92, 0x65, 0xa3, 0x4f, 0x27, 0x67, 0x96,
-       0x0c, 0x8c, 0x3f, 0x10, 0x78, 0x24, 0x52, 0x9e,
-       0x7a, 0x9b, 0x79, 0x1d, 0x9d, 0xa3, 0xb5, 0x72,
-       0xe5, 0x21, 0xd3, 0x9e, 0x62, 0x70, 0x2e, 0x3c,
-       0xa0, 0x8c, 0xef, 0xd1, 0x2b, 0x63, 0x97, 0x54,
-       0xf8, 0x46, 0xcb, 0x67, 0xc8, 0xe6, 0xd4, 0xfa,
-       0x66, 0xe9, 0xf5, 0x26, 0x93, 0xce, 0x08, 0x38,
-       0x6b, 0xb3, 0x3c, 0x17, 0x5f, 0x67, 0x92, 0xa9,
-       0x14, 0xe3, 0x3c, 0x22, 0x51, 0xe9, 0xc5, 0xfa,
-       0x1f, 0x1d, 0xf3, 0x47, 0x78, 0x8f, 0x6b, 0x2f,
-       0xe9, 0xe4, 0x4d, 0xf5, 0xf0, 0x22, 0xd3, 0xc3,
-       0xf3, 0x58, 0xcb, 0xcc, 0xea, 0x88, 0xc7, 0x20,
-       0x5a, 0x50, 0xda, 0x4a, 0xe4, 0x7e, 0x59, 0xf2,
-       0x84, 0x1e, 0x39, 0x50, 0x8e, 0xb1, 0xd3, 0x64,
-       0xcb, 0x91, 0x2e, 0x43, 0x58, 0x86, 0xcf, 0xac,
-       0x55, 0x9d, 0x3e, 0xa3, 0x92, 0x1a, 0x4a, 0x3c,
-       0x50, 0x2e, 0x8d, 0x47, 0xbe, 0x69, 0x9a, 0x9e,
-       0xc4, 0xb4, 0x02, 0xd3, 0x45, 0xdf, 0x01, 0x0c,
-       0xf9, 0x0c, 0xb2, 0x71, 0x17, 0x28, 0xa9, 0x4e,
-       0xbd, 0xfa, 0xad, 0x13, 0xfa, 0xe2, 0x57, 0x20,
-       0xe4, 0x3c, 0x06, 0xb6, 0xfd, 0xd8, 0xbe, 0xc5,
-       0x3f, 0x83, 0xc8, 0xfc, 0x9e, 0xae, 0x08, 0x7a,
-       0xf9, 0xc1, 0xd7, 0x0b, 0xef, 0x30, 0x1b, 0x60,
-       0xa4, 0x4c, 0x6f, 0x09, 0xbc, 0x48, 0xdc, 0x22,
-       0x58, 0xba, 0xb1, 0x3e, 0xd4, 0xca, 0xeb, 0xab,
-       0x7f, 0x2a, 0xea, 0x3d, 0x09, 0xce, 0xe2, 0x37,
-       0xa2, 0xc4, 0x1f, 0x26, 0xfe, 0x27, 0xc7, 0xd0,
-       0x59, 0x22, 0x58, 0x97, 0xe2, 0x3b, 0x5e, 0x29,
-       0xc7, 0x7a, 0x5a, 0x16, 0x1c, 0xc0, 0xeb, 0x88,
-       0x05, 0x91, 0xe3, 0x80, 0xd0, 0x4a, 0x50, 0x81,
-       0xc1, 0xe6, 0x40, 0x51, 0xc4, 0x2d, 0x9b, 0x51,
-       0x7b, 0x51, 0x4c, 0xb3, 0x78, 0x9e, 0x4b, 0xb6,
-       0xa9, 0xe1, 0x2a, 0x4a, 0x83, 0x1c, 0xe5, 0xe6,
-       0xf5, 0x30, 0x52, 0x31, 0x49, 0x56, 0xcc, 0x07,
-       0x67, 0x59, 0x23, 0x72, 0xe2, 0x4b, 0x1a, 0x68,
-       0xc0, 0x58, 0xab, 0x9c, 0x16, 0xe8, 0x40, 0x38,
-       0x42, 0x4e, 0x46, 0x5a, 0x4b, 0x40, 0xc2, 0x30,
-       0xa5, 0xb4, 0xda, 0xe8, 0x3b, 0x66, 0x41, 0x5f,
-       0xb9, 0x62, 0xf5, 0x25, 0x28, 0xf0, 0x47, 0xea,
-       0xcb, 0x53, 0xc5, 0x03, 0x58, 0xaf, 0x5b, 0x22,
-       0x5d, 0x83, 0xae, 0x9e, 0xae, 0x25, 0x58, 0xce,
-       0x3f, 0x7e, 0x14, 0x98, 0x19, 0x99, 0x9f, 0x07,
-       0x8a, 0x40, 0x27, 0x90, 0x37, 0xd2, 0xbd, 0xfd,
-       0x51, 0xf5, 0xf0, 0xc7, 0x5e, 0x7a, 0x16, 0xd2,
-       0x04, 0x7f, 0x3c, 0x84, 0x3d, 0xc0, 0x22, 0x1a,
-       0xf1, 0x9a, 0x45, 0xb6, 0x23, 0xc1, 0xed, 0xdb,
-       0x9d, 0x77, 0x48, 0x60, 0xde, 0xc9, 0xfb, 0x8b,
-       0xbb, 0x8f, 0x7d, 0x5d, 0xe6, 0x3e, 0xb4, 0x88,
-       0x8f, 0xb0, 0xc7, 0x58, 0x1a, 0x92, 0xa5, 0xd4,
-       0x00, 0x20, 0x77, 0x92, 0x21, 0x22, 0xc2, 0xed,
-       0x03, 0xbe, 0xdb, 0x96, 0x0e, 0xd2, 0xae, 0x65,
-       0x11, 0xcc, 0x3b, 0x02, 0xfd, 0x91, 0xf9, 0x98,
-       0xdf, 0x0a, 0x4a, 0x6f, 0x19, 0x2b, 0x26, 0x07,
-       0x4e, 0x33, 0x5c, 0x66, 0x38, 0xd6, 0x2c, 0xf1,
-       0x3c, 0xed, 0x16, 0xa3, 0xda, 0x39, 0xef, 0x28,
-       0xf9, 0x3d, 0x5c, 0x13, 0xb3, 0x9c, 0x3a, 0x6c,
-       0xd9, 0xe3, 0x18, 0xd3, 0x8b, 0x31, 0xac, 0xde,
-       0xa2, 0x8d, 0xd1, 0x0e, 0x20, 0x5e, 0x9f, 0xf3,
-       0x30, 0xc6, 0xec, 0xe6, 0xbc, 0x42, 0x12, 0xe6,
-       0x66, 0x66, 0x71, 0x3b, 0x30, 0xae, 0x3c, 0xa7,
-       0x15, 0xe3, 0xb6, 0x0a, 0x18, 0x67, 0x1e, 0x14,
-       0xcf, 0x30, 0xfa, 0x46, 0x92, 0x91, 0x83, 0x33,
-       0x91, 0xc4, 0x75, 0x36, 0x9d, 0x37, 0x8c, 0xa9,
-       0x40, 0x3c, 0xc4, 0x62, 0x9e, 0x14, 0x4d, 0x0c,
-       0x6e, 0xa5, 0xf3, 0x2e, 0x94, 0xe7, 0xc5, 0xd7,
-       0x31, 0x7c, 0x48, 0x84, 0xc4, 0x27, 0xb4, 0x16,
-       0x14, 0xcd, 0x43, 0xbd, 0x3a, 0xe9, 0x65, 0x8c,
-       0xe9, 0x42, 0x29, 0x5d, 0xce, 0xe2, 0x4f, 0x22,
-       0x11, 0x37, 0xdd, 0xcd, 0x52, 0x8c, 0x22, 0x24,
-       0xad, 0xe3, 0x36, 0x91, 0xf4, 0x24, 0xe9, 0x29,
-       0x00, 0xb6, 0x3b, 0x64, 0x18, 0xd8, 0x60, 0xc3,
-       0xba, 0x8d, 0x0d, 0x60, 0x8a, 0x2d, 0x92, 0x19,
-       0xaf, 0xcf, 0xa8, 0x6d, 0x87, 0xf1, 0xce, 0x3b,
-       0x44, 0x18, 0xbb, 0xc0, 0xfa, 0x80, 0x2e, 0xa2,
-       0x5c, 0x14, 0x61, 0x40, 0xa4, 0x36, 0x59, 0x57,
-       0x84, 0x69, 0x16, 0x38, 0x6f, 0x59, 0xd1, 0x41,
-       0x4f, 0x47, 0x65, 0xfd, 0x8a, 0x4e, 0xdb, 0x1b,
-       0x18, 0xb2, 0xb0, 0x5d, 0xe5, 0x6d, 0x12, 0x98,
-       0x5e, 0x62, 0x36, 0x68, 0xc6, 0x5e, 0x3d, 0x33,
-       0x52, 0x82, 0xbc, 0x59, 0xb4, 0xaf, 0x92, 0xbe,
-       0x70, 0x9b, 0x68, 0x23, 0xfb, 0xa6, 0x5e, 0xee,
-       0x34, 0x20, 0x66, 0x76, 0x1a, 0xce, 0xd5, 0xa9,
-       0x79, 0x35, 0x8a, 0x60, 0xba, 0x4a, 0x79, 0x3a,
-       0xef, 0x88, 0xb0, 0xdd, 0x85, 0x58, 0xa2, 0x7a,
-       0x67, 0x71, 0x94, 0x95, 0xdd, 0xcc, 0xca, 0x6e,
-       0x3e, 0xc8, 0xcb, 0x6e, 0x3e, 0xca, 0xdb, 0xe8,
-       0xd3, 0xa3, 0xac, 0x8d, 0x57, 0x88, 0x69, 0xbc,
-       0x8d, 0x3e, 0xdd, 0xcf, 0xf0, 0xd5, 0x5c, 0x4f,
-       0xe6, 0x72, 0x2c, 0xc9, 0x0c, 0xe4, 0x7e, 0xbe,
-       0x10, 0x3d, 0x45, 0x62, 0x94, 0x4a, 0xf2, 0xe9,
-       0x73, 0xe6, 0x47, 0xb1, 0xc4, 0xd8, 0x37, 0xcc,
-       0x4f, 0x72, 0x59, 0xba, 0x64, 0xf4, 0x46, 0x16,
-       0xe4, 0x5a, 0x8a, 0x7d, 0x75, 0x13, 0x42, 0xd4,
-       0xbc, 0x29, 0x13, 0xe1, 0x62, 0xd4, 0x72, 0x82,
-       0x42, 0xa7, 0x03, 0x4f, 0x23, 0xbf, 0x68, 0x4a,
-       0xc1, 0xf2, 0x55, 0xb1, 0xf2, 0xa1, 0x37, 0xbd,
-       0xed, 0x45, 0xc4, 0x4a, 0x91, 0xc3, 0xa0, 0xe0,
-       0xc8, 0x6f, 0xc2, 0x99, 0x8b, 0xc9, 0x81, 0xd0,
-       0x81, 0xb0, 0xd2, 0x79, 0x4b, 0x4f, 0x97, 0x1b,
-       0x14, 0xbb, 0xc5, 0x95, 0x04, 0x91, 0xae, 0x1f,
-       0x63, 0x1f, 0xf9, 0x34, 0x4b, 0xb4, 0x38, 0x8b,
-       0x75, 0x51, 0x56, 0xc6, 0xf1, 0xa8, 0x9b, 0x47,
-       0xc1, 0x8c, 0xbf, 0x24, 0x19, 0xe7, 0xc0, 0x66,
-       0x13, 0x2b, 0x87, 0x89, 0xbe, 0xae, 0x9e, 0xf8,
-       0x51, 0xc9, 0xc0, 0xb8, 0xdf, 0x9f, 0x9e, 0x6d,
-       0xbb, 0x4d, 0x81, 0xab, 0x57, 0x7a, 0x50, 0xb6,
-       0xf9, 0x36, 0xf4, 0x38, 0x03, 0x22, 0x6a, 0xde,
-       0x64, 0xbb, 0x50, 0x11, 0x30, 0x44, 0xdc, 0xe8,
-       0x7d, 0xe8, 0x0b, 0xc5, 0x0d, 0x55, 0x38, 0x4c,
-       0xb7, 0xd4, 0xcf, 0xd4, 0x49, 0x7d, 0x79, 0x13,
-       0xb0, 0xb4, 0x7a, 0xfa, 0xa1, 0x64, 0x1d, 0x80,
-       0x6c, 0x96, 0xac, 0x4c, 0x66, 0x9e, 0xe4, 0x24,
-       0x88, 0x32, 0x0b, 0xf2, 0x0c, 0xfb, 0x71, 0x8d,
-       0xb3, 0x73, 0x9e, 0x62, 0xf1, 0xcd, 0x5b, 0x52,
-       0x21, 0x5f, 0x11, 0xe1, 0xea, 0xd3, 0xb5, 0x15,
-       0xf4, 0xfd, 0x32, 0x9c, 0xdb, 0x9b, 0xd9, 0x55,
-       0x6f, 0x7b, 0x17, 0x7b, 0x1c, 0xae, 0xa0, 0x71,
-       0x66, 0x5b, 0xc7, 0xce, 0x02, 0x1c, 0x04, 0xda,
-       0x97, 0x8b, 0x9e, 0x67, 0x81, 0x23, 0x1a, 0xb5,
-       0x45, 0xaa, 0x3a, 0x0b, 0xee, 0x30, 0xeb, 0xe9,
-       0x9b, 0x28, 0x57, 0x17, 0x4b, 0x0e, 0x66, 0xff,
-       0x7a, 0xb1, 0xd7, 0x79, 0x8b, 0x99, 0x7d, 0x27,
-       0xe5, 0x6a, 0xb9, 0x74, 0x80, 0x68, 0x05, 0x77,
-       0x88, 0xd6, 0x82, 0x3b, 0x9c, 0x7a, 0x92, 0x83,
-       0x54, 0x9c, 0x0f, 0x25, 0x66, 0x90, 0x8f, 0x77,
-       0xea, 0x2f, 0x78, 0xa5, 0x64, 0xe6, 0xdd, 0xf4,
-       0x92, 0x89, 0x7b, 0x71, 0x4c, 0x99, 0x20, 0x5b,
-       0x23, 0xc5, 0x30, 0x41, 0xd6, 0x07, 0x04, 0x11,
-       0xec, 0x2e, 0xf6, 0x84, 0x1d, 0xfe, 0x30, 0x40,
-       0xef, 0x09, 0x23, 0xbc, 0x44, 0x76, 0x81, 0xf1,
-       0x89, 0xfc, 0x6c, 0x42, 0xfe, 0xdd, 0x2a, 0x11,
-       0x8c, 0x6f, 0x33, 0xcd, 0x8f, 0x93, 0x20, 0xc1,
-       0x38, 0x05, 0xf5, 0x6e, 0xec, 0xa1, 0xb7, 0x7f,
-       0x26, 0x67, 0xb3, 0x30, 0xd9, 0xf7, 0x64, 0x3a,
-       0xb1, 0xdd, 0xf8, 0x3c, 0xed, 0x05, 0xc7, 0x91,
-       0xa2, 0xa0, 0xe0, 0x96, 0x03, 0x5d, 0x7f, 0x13,
-       0xdd, 0xc5, 0xfc, 0xdd, 0x1f, 0x9e, 0xc5, 0x76,
-       0x1a, 0xc8, 0xbb, 0xe3, 0xdc, 0x22, 0xd4, 0xe9,
-       0xc5, 0x90, 0xcd, 0xbc, 0x16, 0x73, 0xd4, 0x87,
-       0xec, 0x08, 0xa9, 0x2d, 0x6d, 0xeb, 0x3c, 0x48,
-       0x7f, 0x70, 0x9d, 0x07, 0xb9, 0x5a, 0xd5, 0x9e,
-       0xb2, 0x13, 0xe7, 0x12, 0x5d, 0x4e, 0xd4, 0x8a,
-       0x6c, 0xa4, 0xb1, 0xa2, 0x64, 0xe0, 0xf6, 0x6f,
-       0xd1, 0x97, 0xa1, 0xc7, 0x7c, 0x02, 0x46, 0xde,
-       0xd7, 0x0c, 0xc7, 0xc9, 0xd2, 0x9c, 0xba, 0xdf,
-       0xb2, 0xb1, 0xa2, 0x50, 0xf7, 0xd1, 0xec, 0x83,
-       0x5d, 0x50, 0x14, 0x2e, 0xc9, 0x03, 0x94, 0x95,
-       0xa2, 0xf6, 0x33, 0x1d, 0xbd, 0x4b, 0x8a, 0xeb,
-       0xa0, 0x3e, 0xdf, 0x2d, 0x58, 0x0a, 0xfb, 0x4c,
-       0xdd, 0x50, 0xff, 0xfb, 0x83, 0x85, 0xfa, 0x5f,
-       0x5a, 0x3f, 0xb5, 0x64, 0x02, 0x8e, 0xad, 0x86,
-       0x6e, 0xea, 0x65, 0xc9, 0xd8, 0xcb, 0xae, 0xf4,
-       0x3b, 0x6f, 0x21, 0x1d, 0x20, 0xed, 0x24, 0xf7,
-       0x38, 0x17, 0xbc, 0x2a, 0x7e, 0x04, 0x79, 0x77,
-       0x87, 0x1e, 0x46, 0x4d, 0x24, 0x29, 0xfa, 0x50,
-       0xab, 0x6d, 0x3f, 0xd2, 0xaa, 0x33, 0x6e, 0x39,
-       0xb0, 0x37, 0xb9, 0x88, 0xa5, 0xdc, 0x9d, 0x71,
-       0x0b, 0x6f, 0xa5, 0x0b, 0x1b, 0x24, 0x5c, 0x07,
-       0x1a, 0x4e, 0x64, 0x3b, 0xa8, 0x77, 0x5c, 0xa3,
-       0xf0, 0xfb, 0x93, 0xa7, 0xe1, 0xc4, 0x9a, 0xb0,
-       0x14, 0xfe, 0x4d, 0x2d, 0x3a, 0x91, 0x50, 0x95,
-       0x1b, 0xc2, 0xf6, 0x01, 0xc3, 0x4b, 0xd3, 0xb0,
-       0x3f, 0x1a, 0x9a, 0x59, 0x8b, 0x8f, 0x50, 0xe0,
-       0x4a, 0xb3, 0x68, 0xe1, 0x61, 0x94, 0xbc, 0x04,
-       0xb5, 0x5d, 0xad, 0xb6, 0x3f, 0x7c, 0xd6, 0x8b,
-       0x23, 0xb7, 0x1b, 0xe1, 0xdb, 0xd4, 0xe7, 0x8c,
-       0x47, 0x69, 0xd4, 0x0c, 0x50, 0xa9, 0x40, 0xd1,
-       0x07, 0x5a, 0x6d, 0x11, 0x5c, 0x51, 0xbd, 0xc6,
-       0x6b, 0xaa, 0xd3, 0xc9, 0x26, 0xf2, 0x26, 0x69,
-       0x66, 0x81, 0xae, 0x7a, 0xea, 0x47, 0xc6, 0xed,
-       0x92, 0x5e, 0x3c, 0xc2, 0x7b, 0xef, 0x15, 0x23,
-       0xc5, 0x1a, 0xf7, 0x22, 0xe5, 0x35, 0xde, 0xbf,
-       0x7f, 0x7f, 0x89, 0x51, 0x9e, 0xf6, 0x3d, 0xb0,
-       0xf0, 0x67, 0x38, 0xa7, 0xb9, 0x4a, 0x63, 0x56,
-       0x36, 0xb6, 0xe1, 0xef, 0x4f, 0x38, 0xef, 0x20,
-       0xeb, 0x44, 0xd9, 0x07, 0x31, 0xbe, 0xc7, 0xfa,
-       0x40, 0x06, 0x10, 0x87, 0xf5, 0x81, 0xe7, 0x28,
-       0x76, 0x2f, 0xa3, 0xdd, 0x02, 0x05, 0x0a, 0xf6,
-       0xeb, 0xdf, 0xbf, 0x8c, 0x21, 0xa7, 0x7c, 0xc5,
-       0x79, 0x47, 0xd0, 0xbe, 0xdf, 0x25, 0x8f, 0x0d,
-       0x26, 0x86, 0x3a, 0xf6, 0xbb, 0x14, 0x73, 0xa8,
-       0xb1, 0x46, 0x87, 0xbc, 0x1b, 0x49, 0x6f, 0xfa,
-       0xd7, 0xe5, 0x06, 0xd1, 0xbe, 0xb3, 0x0b, 0xec,
-       0x0a, 0xfc, 0x7e, 0x4d, 0x70, 0x12, 0x59, 0xbd,
-       0xa2, 0x0f, 0x36, 0xda, 0xf6, 0x49, 0x90, 0x7a,
-       0x15, 0xe3, 0x9f, 0xcd, 0x9e, 0x74, 0x1e, 0x57,
-       0x33, 0xfa, 0x3a, 0x6a, 0x97, 0xcf, 0xae, 0xf6,
-       0x74, 0x09, 0x36, 0x4c, 0x5b, 0x8b, 0xa5, 0xd8,
-       0x0b, 0x41, 0xda, 0xef, 0x21, 0xeb, 0x17, 0xd3,
-       0xb9, 0x1d, 0xbd, 0x7c, 0xec, 0x49, 0x3d, 0x80,
-       0x25, 0x18, 0x4b, 0xbc, 0x1f, 0xd8, 0x7b, 0xba,
-       0xd6, 0x12, 0xaf, 0xa3, 0xe0, 0x16, 0x09, 0x47,
-       0x07, 0x7d, 0x6d, 0xf6, 0x24, 0xa7, 0xfe, 0x37,
-       0x75, 0x38, 0xd6, 0xe3, 0xa8, 0xfa, 0x7b, 0xf4,
-       0x88, 0xa9, 0x5b, 0xe8, 0xe9, 0x60, 0xb6, 0xf4,
-       0xeb, 0x3a, 0xca, 0x55, 0x84, 0xd4, 0x6e, 0xd4,
-       0xb3, 0x07, 0xd7, 0x3c, 0x70, 0xf9, 0xb2, 0x34,
-       0x8e, 0xfa, 0x92, 0x8a, 0x7d, 0x24, 0x8d, 0xdd,
-       0xa4, 0xdf, 0x8f, 0x7d, 0x41, 0x81, 0xcb, 0x27,
-       0xd4, 0xbe, 0x88, 0x2d, 0x73, 0xf9, 0xed, 0xa1,
-       0x96, 0xb9, 0xbc, 0xdf, 0x59, 0xfc, 0xe8, 0xd5,
-       0x88, 0x07, 0x43, 0x7b, 0xb4, 0x31, 0x01, 0xdb,
-       0xf2, 0x79, 0x6a, 0xab, 0x3c, 0x3d, 0xf2, 0x58,
-       0xe8, 0x5c, 0x44, 0xdd, 0x13, 0xd4, 0x0b, 0xc9,
-       0xfe, 0x75, 0xeb, 0xce, 0x2d, 0x42, 0xbc, 0x8b,
-       0xcb, 0xc5, 0x54, 0xeb, 0xe8, 0x04, 0x20, 0xc3,
-       0xc9, 0xdf, 0x62, 0x9c, 0xe1, 0x28, 0xf6, 0x88,
-       0x64, 0xde, 0x2b, 0xcc, 0xfb, 0x20, 0x01, 0x7f,
-       0x98, 0xd6, 0x50, 0xc7, 0xe2, 0x66, 0xa8, 0x71,
-       0xd6, 0x58, 0x7c, 0x32, 0xf1, 0x60, 0x7c, 0x11,
-       0x8b, 0x1f, 0xcf, 0x52, 0xe8, 0xb0, 0xac, 0x66,
-       0x3a, 0xf1, 0x08, 0x29, 0x74, 0x52, 0x20, 0x9d,
-       0xbf, 0x73, 0x9e, 0xf9, 0x28, 0x0b, 0xfa, 0x28,
-       0xcc, 0x17, 0x35, 0x7a, 0x19, 0xe9, 0x46, 0xd5,
-       0x13, 0xd3, 0xd3, 0x40, 0x3a, 0x0b, 0xa7, 0x0f,
-       0x21, 0xb6, 0x21, 0xbc, 0x27, 0xf1, 0x2f, 0x1c,
-       0xbe, 0x2d, 0x91, 0x6e, 0xc7, 0x66, 0x63, 0xcf,
-       0xff, 0xec, 0x20, 0xf9, 0xc9, 0x4f, 0xeb, 0x91,
-       0xba, 0x17, 0xf5, 0x76, 0x98, 0xbe, 0x85, 0x88,
-       0xf2, 0xcc, 0x8a, 0x59, 0x4c, 0xe1, 0xa7, 0x40,
-       0x05, 0x1e, 0xd6, 0xc6, 0x40, 0xd1, 0x12, 0x68,
-       0xd5, 0xb4, 0x40, 0x56, 0x69, 0x8b, 0x88, 0x39,
-       0x4e, 0xdd, 0x47, 0xde, 0x8d, 0x5d, 0xb8, 0xf2,
-       0x35, 0x53, 0x48, 0xd4, 0x53, 0xcf, 0x06, 0x7a,
-       0xc6, 0x14, 0x51, 0xe0, 0x77, 0x8f, 0x5d, 0xf0,
-       0xb2, 0x35, 0x07, 0xe7, 0xfe, 0x23, 0x8c, 0xa3,
-       0x53, 0x55, 0x63, 0xeb, 0x05, 0x4b, 0x6c, 0x26,
-       0x71, 0x6b, 0x55, 0x67, 0xfd, 0xc3, 0xad, 0x59,
-       0x7c, 0x2c, 0xc0, 0x7e, 0x0a, 0xbf, 0xad, 0x43,
-       0xff, 0x85, 0xe3, 0xe6, 0x98, 0xcd, 0xea, 0x58,
-       0x26, 0x89, 0x66, 0x6d, 0x54, 0xd3, 0x38, 0xe2,
-       0x3c, 0xd8, 0x4d, 0x38, 0x86, 0x79, 0xb8, 0x6c,
-       0x29, 0x5b, 0x0e, 0x5c, 0xf4, 0x8a, 0x7d, 0xdc,
-       0x7b, 0xa7, 0x35, 0x8a, 0x29, 0x6a, 0xe8, 0x41,
-       0x9e, 0x0a, 0x43, 0x75, 0xb6, 0xbf, 0x33, 0x6f,
-       0x41, 0xfd, 0xe2, 0xec, 0x7e, 0x6a, 0x52, 0x7a,
-       0x3b, 0x18, 0xc9, 0x97, 0xa7, 0x3f, 0x54, 0xfb,
-       0xdd, 0x78, 0x5c, 0xf5, 0xeb, 0x48, 0xaf, 0x43,
-       0xba, 0xed, 0xb6, 0x1a, 0x58, 0x86, 0x74, 0x91,
-       0xad, 0x08, 0x30, 0xcf, 0x22, 0xac, 0xb7, 0x20,
-       0x5b, 0x43, 0xa3, 0xce, 0xcc, 0xfe, 0x55, 0x35,
-       0x9d, 0xfb, 0x53, 0x08, 0x9e, 0x04, 0x8f, 0x27,
-       0xd0, 0x28, 0xe9, 0x03, 0xd2, 0x4a, 0xb3, 0xaf,
-       0x54, 0xa9, 0x4c, 0x30, 0xc8, 0x26, 0xbf, 0xa7,
-       0xa6, 0x54, 0xbc, 0xe4, 0xfb, 0xa9, 0xfa, 0xce,
-       0x58, 0xc4, 0xb6, 0xce, 0x64, 0x03, 0x27, 0xe6,
-       0x6e, 0xf0, 0xb0, 0x38, 0xc5, 0x9c, 0x60, 0x50,
-       0x8c, 0xd5, 0x07, 0x91, 0xc7, 0xa4, 0xd0, 0xf8,
-       0x3e, 0x45, 0xe5, 0x99, 0x4a, 0x3c, 0x28, 0xc5,
-       0x54, 0x53, 0xea, 0xf7, 0x88, 0x3d, 0x5a, 0xae,
-       0x0a, 0x5c, 0x1a, 0x4b, 0xfb, 0x6c, 0x10, 0xa6,
-       0x74, 0x05, 0x8e, 0x3c, 0xba, 0x17, 0xfb, 0x5a,
-       0x57, 0xb4, 0x2f, 0xf9, 0x24, 0x6a, 0x80, 0x95,
-       0x68, 0x3c, 0xcd, 0x5f, 0x15, 0xf8, 0xe4, 0x32,
-       0x42, 0xab, 0x0c, 0x9f, 0x5c, 0x08, 0x25, 0x9e,
-       0x19, 0xf1, 0x2b, 0x7a, 0xf7, 0x61, 0x20, 0x0d,
-       0x44, 0x33, 0x51, 0x31, 0xf6, 0x3d, 0x84, 0x23,
-       0x94, 0x64, 0xdf, 0xfa, 0x65, 0xf0, 0xc9, 0x61,
-       0xf6, 0x1d, 0xdc, 0x83, 0x55, 0x9d, 0x1e, 0x08,
-       0x25, 0xfa, 0x3c, 0xcb, 0xae, 0x60, 0xb9, 0x8d,
-       0x35, 0x1e, 0xf1, 0xb2, 0x2f, 0x12, 0x7b, 0xd3,
-       0x8d, 0xcd, 0x43, 0xb1, 0xbf, 0xde, 0xf3, 0xb7,
-       0x76, 0x8f, 0xa9, 0xc6, 0xb3, 0x4c, 0x2b, 0xf5,
-       0x65, 0x2c, 0x75, 0x0a, 0x2b, 0xf5, 0x10, 0x4f,
-       0xe1, 0xdf, 0xda, 0x51, 0x4a, 0x0f, 0x4a, 0xd8,
-       0x89, 0xab, 0xb3, 0xcb, 0x91, 0xae, 0x51, 0x70,
-       0xd1, 0x5b, 0x82, 0x3e, 0x5f, 0xd3, 0x28, 0x8d,
-       0x02, 0x63, 0x68, 0xe7, 0xd5, 0xa8, 0x5e, 0x17,
-       0xa7, 0x73, 0x5a, 0xaa, 0x19, 0x69, 0x13, 0x7a,
-       0x5d, 0x1a, 0x15, 0xb9, 0x93, 0x87, 0x8d, 0xb1,
-       0xbf, 0x54, 0xb5, 0x30, 0x13, 0x6b, 0x7a, 0x6f,
-       0x03, 0x1b, 0x4f, 0xa8, 0x45, 0x69, 0x76, 0x7d,
-       0xd6, 0xeb, 0x5d, 0x0d, 0x16, 0xe7, 0x7d, 0x60,
-       0x7a, 0x17, 0x5b, 0x0b, 0x6c, 0x20, 0x40, 0x01,
-       0x2c, 0x80, 0x95, 0xb0, 0x15, 0x8e, 0xe8, 0x69,
-       0x66, 0xd4, 0x18, 0x48, 0x8c, 0xb8, 0xe3, 0xec,
-       0x44, 0xba, 0x0e, 0xcf, 0x56, 0xbf, 0xa1, 0x18,
-       0x47, 0x27, 0xef, 0xce, 0xde, 0x10, 0x03, 0xa3,
-       0xf7, 0xf3, 0x39, 0xf0, 0x77, 0x37, 0x72, 0xe1,
-       0xcc, 0xdd, 0x98, 0xae, 0x6a, 0xc2, 0x11, 0xe3,
-       0x40, 0x6e, 0x4d, 0x8e, 0xe1, 0x3c, 0x72, 0xd0,
-       0x77, 0x40, 0x1d, 0xce, 0x5b, 0x90, 0xbf, 0x4d,
-       0xb3, 0xe5, 0xeb, 0xf3, 0x33, 0xe0, 0x3c, 0xcc,
-       0x1b, 0x79, 0xf7, 0x55, 0xec, 0x2f, 0xd8, 0x7f,
-       0x0d, 0x6f, 0x9b, 0x6f, 0xa1, 0x6f, 0x50, 0xc3,
-       0x56, 0x8c, 0xd9, 0xa1, 0xa5, 0x36, 0x0c, 0xd2,
-       0x57, 0x53, 0x38, 0xcf, 0x4d, 0xe5, 0x64, 0x07,
-       0x1a, 0x31, 0x5d, 0x22, 0x8e, 0x22, 0x98, 0x7f,
-       0x20, 0x10, 0xb9, 0xa5, 0xcf, 0xcc, 0xe3, 0x68,
-       0x57, 0xa8, 0xb3, 0x18, 0xfa, 0x23, 0xb7, 0x9c,
-       0x65, 0x6f, 0x73, 0x5d, 0x3e, 0x98, 0x9e, 0xcb,
-       0xbe, 0x4e, 0x9a, 0x13, 0x68, 0xc5, 0x14, 0xd8,
-       0xf2, 0x81, 0x87, 0xbd, 0xfb, 0x30, 0x8d, 0x29,
-       0x72, 0x8b, 0x62, 0x39, 0x43, 0x3d, 0x26, 0x0b,
-       0x7b, 0xb3, 0xfd, 0x83, 0xef, 0xfd, 0x42, 0xcb,
-       0x6d, 0x32, 0xed, 0x1b, 0xad, 0x9d, 0x83, 0x65,
-       0xcb, 0xcb, 0xcd, 0x2b, 0x28, 0x0a, 0x98, 0x69,
-       0xb4, 0x31, 0x98, 0x03, 0xb3, 0x70, 0x84, 0x29,
-       0x86, 0xd2, 0x46, 0xd0, 0xd3, 0x1e, 0x18, 0xa3,
-       0x82, 0xfe, 0x29, 0xe0, 0x8c, 0xcc, 0x47, 0x78,
-       0x61, 0xa6, 0xbe, 0xe0, 0x0e, 0x55, 0x2f, 0x1e,
-       0x66, 0x53, 0xf7, 0xe3, 0xdc, 0x16, 0x67, 0xa6,
-       0x70, 0x9f, 0x5c, 0x87, 0x3c, 0x9e, 0x3e, 0x2f,
-       0xfa, 0xd7, 0x44, 0x3a, 0xc7, 0x56, 0x37, 0xde,
-       0xea, 0x80, 0xfb, 0xd5, 0x77, 0x2c, 0xa9, 0x5e,
-       0xab, 0xc5, 0x6c, 0x5c, 0x19, 0x3a, 0xf0, 0x67,
-       0x15, 0x46, 0xf6, 0xfe, 0x8f, 0xf9, 0x61, 0x09,
-       0x46, 0x19, 0xc5, 0x54, 0xd2, 0x51, 0xef, 0x5f,
-       0x2f, 0x42, 0x2c, 0xf9, 0x0a, 0xf3, 0x38, 0x83,
-       0xf0, 0xb0, 0x9a, 0x22, 0x40, 0x33, 0x3c, 0x71,
-       0x1a, 0x97, 0x8b, 0x5e, 0xf0, 0x08, 0x69, 0x86,
-       0xe4, 0xcb, 0x82, 0x2a, 0x9b, 0xde, 0xe3, 0x74,
-       0xc4, 0xe5, 0x21, 0xa9, 0xa7, 0x37, 0x9b, 0x7c,
-       0xa4, 0xe9, 0x2d, 0xc8, 0xab, 0x67, 0x71, 0x0f,
-       0x60, 0xc8, 0x24, 0xd7, 0xde, 0x2c, 0x55, 0xa0,
-       0xd1, 0xe7, 0x59, 0xca, 0xb4, 0xeb, 0x2c, 0x0e,
-       0x40, 0xc4, 0xa3, 0xce, 0xfa, 0x22, 0xaa, 0x26,
-       0x69, 0x44, 0xd1, 0x07, 0x1e, 0xa6, 0x58, 0x13,
-       0xc6, 0x2a, 0x96, 0xdf, 0xd6, 0xa9, 0x9a, 0x34,
-       0x8a, 0x56, 0xd2, 0x9a, 0xb3, 0xf8, 0x1a, 0xd2,
-       0xe5, 0x2c, 0xa6, 0x11, 0x0b, 0xe5, 0x28, 0xb3,
-       0x1c, 0x71, 0x96, 0xea, 0x51, 0xe8, 0x54, 0x69,
-       0x1d, 0xcf, 0x87, 0xcd, 0x46, 0x27, 0x17, 0x4c,
-       0xc0, 0xde, 0x99, 0x28, 0x5e, 0x45, 0x2d, 0x8c,
-       0xa5, 0x75, 0xb2, 0x80, 0xb3, 0x8f, 0x91, 0xd7,
-       0xb0, 0x37, 0x10, 0x8c, 0xd5, 0x1f, 0x47, 0x79,
-       0xb2, 0x01, 0xd7, 0x75, 0x3d, 0x21, 0x0f, 0x3c,
-       0xd0, 0x08, 0x83, 0xba, 0x00, 0xfd, 0x63, 0xad,
-       0x80, 0xb3, 0x97, 0xa5, 0x34, 0x8b, 0x9c, 0x52,
-       0xea, 0xc2, 0xf4, 0xbb, 0x55, 0x2b, 0x56, 0x65,
-       0x10, 0x07, 0x93, 0xff, 0xec, 0xd0, 0xb7, 0x45,
-       0x03, 0xd7, 0x7a, 0x1f, 0x20, 0x7d, 0x23, 0xb5,
-       0x3b, 0x5e, 0xcb, 0x9c, 0x83, 0x5b, 0xe8, 0x67,
-       0x57, 0xb9, 0x75, 0x92, 0x65, 0xf6, 0xfe, 0x35,
-       0xbd, 0x63, 0x74, 0x19, 0xd7, 0x58, 0x23, 0xeb,
-       0xae, 0xe3, 0xff, 0x2f, 0xb1, 0x4c, 0xd8, 0x42,
-       0x3a, 0xd6, 0xd6, 0x60, 0x3e, 0x76, 0xef, 0x46,
-       0xb6, 0xa0, 0xbd, 0x45, 0xeb, 0x1f, 0x14, 0xc1,
-       0x7a, 0x80, 0xef, 0x91, 0x44, 0x1a, 0x8e, 0x87,
-       0xd6, 0xdd, 0x7c, 0x6f, 0x25, 0x62, 0x29, 0x5e,
-       0x17, 0xcd, 0x99, 0xac, 0xcf, 0x5b, 0xf9, 0xdd,
-       0xac, 0x1f, 0x2b, 0x4e, 0xeb, 0xbd, 0x7c, 0x9e,
-       0x2a, 0x27, 0x53, 0x1c, 0xae, 0x72, 0x16, 0xd3,
-       0xfc, 0xcb, 0x5a, 0x87, 0xf4, 0x04, 0xc6, 0x91,
-       0x6c, 0xa5, 0xfd, 0x25, 0x4c, 0x96, 0x74, 0x52,
-       0x64, 0xf7, 0x43, 0xd8, 0x69, 0xa9, 0x58, 0x7e,
-       0x6a, 0x8d, 0x0f, 0xbd, 0x93, 0x3e, 0x41, 0x5f,
-       0x84, 0xe5, 0x4b, 0x7f, 0x08, 0x35, 0xc5, 0x73,
-       0x7a, 0x4d, 0x29, 0x52, 0x43, 0xff, 0xac, 0xe4,
-       0x4c, 0x35, 0xd3, 0x1d, 0xcf, 0xcb, 0xaf, 0xc7,
-       0x46, 0xc8, 0x42, 0x5a, 0x6b, 0xb3, 0x32, 0xef,
-       0x55, 0x8c, 0x88, 0xe3, 0x3a, 0x67, 0xc4, 0x59,
-       0xda, 0x7f, 0x75, 0x79, 0x2f, 0x3b, 0x6b, 0x1d,
-       0xd4, 0xfb, 0x59, 0xff, 0x8c, 0xeb, 0x11, 0x58,
-       0x6a, 0x2a, 0x25, 0x1d, 0x4d, 0x61, 0xab, 0xbe,
-       0xa8, 0x3a, 0xde, 0xfe, 0x33, 0xad, 0xbc, 0xac,
-       0xf5, 0xec, 0x8e, 0xd4, 0x71, 0x7e, 0xfa, 0x61,
-       0x5c, 0x1a, 0x17, 0xa6, 0x71, 0x69, 0x69, 0xa2,
-       0xc3, 0xd3, 0xe4, 0xf0, 0xbb, 0x58, 0x94, 0x86,
-       0xbe, 0xcc, 0x03, 0xc9, 0xf4, 0x92, 0x21, 0x14,
-       0x19, 0x36, 0x19, 0xd6, 0x19, 0x0e, 0x1a, 0x76,
-       0x1b, 0x3e, 0x32, 0x5c, 0x35, 0x9a, 0x8d, 0x19,
-       0xc6, 0x69, 0xc6, 0x52, 0x43, 0x9b, 0x71, 0x4f,
-       0x02, 0xae, 0x1c, 0x8c, 0x60, 0x39, 0x6b, 0x11,
-       0x13, 0x0a, 0x12, 0x8a, 0x13, 0x4a, 0x13, 0xea,
-       0x12, 0xea, 0x13, 0xe4, 0xc4, 0xaa, 0xc4, 0x27,
-       0x2c, 0xd3, 0x2c, 0xa5, 0x96, 0xb0, 0x65, 0xab,
-       0x65, 0xb7, 0xe5, 0x75, 0xcb, 0x41, 0xcb, 0x69,
-       0xcb, 0x89, 0x84, 0x2b, 0x90, 0x97, 0x90, 0x6c,
-       0x5a, 0x63, 0x5a, 0x60, 0x5a, 0x6a, 0x3a, 0x6e,
-       0x78, 0xd9, 0xf0, 0x6c, 0xe2, 0x33, 0x89, 0x7b,
-       0x13, 0xfb, 0xcc, 0x5e, 0x73, 0xad, 0xb9, 0xd5,
-       0xfc, 0xbc, 0x39, 0x64, 0x79, 0x3b, 0xe9, 0x62,
-       0xd2, 0x99, 0xa4, 0xc3, 0x49, 0x7b, 0x4d, 0xa7,
-       0x0d, 0x17, 0xcd, 0x2f, 0x9b, 0x5f, 0x34, 0x54,
-       0x1a, 0xfb, 0xcd, 0x6f, 0xeb, 0x0f, 0x26, 0x6c,
-       0x4a, 0xe8, 0x32, 0x5f, 0x4c, 0xb2, 0x26, 0xd5,
-       0x25, 0x3d, 0x96, 0x70, 0x2c, 0xa1, 0x2f, 0x31,
-       0xd9, 0x78, 0xda, 0x50, 0x6c, 0x8e, 0x98, 0xf7,
-       0x1a, 0x7a, 0x0d, 0xc7, 0x93, 0xf4, 0xe6, 0x2b,
-       0xe6, 0x63, 0x09, 0x97, 0x12, 0x1d, 0xc6, 0x6a,
-       0xe3, 0x62, 0x38, 0xab, 0x1f, 0xa7, 0xb7, 0xeb,
-       0x2e, 0x46, 0xa3, 0xbe, 0x41, 0xa3, 0xae, 0x85,
-       0x7d, 0x5b, 0xfb, 0x02, 0xd6, 0xb3, 0x2a, 0x60,
-       0xd4, 0x05, 0x9b, 0x3a, 0x9a, 0x2e, 0xb3, 0x9d,
-       0xcd, 0x55, 0x5f, 0x37, 0xea, 0xda, 0xda, 0xfb,
-       0xd5, 0x7d, 0xce, 0x55, 0x1d, 0x18, 0x17, 0xfa,
-       0x50, 0xc3, 0x3a, 0x09, 0xfb, 0x9d, 0x86, 0x3d,
-       0x4c, 0xd8, 0x25, 0x15, 0xf3, 0x0d, 0x18, 0x75,
-       0xf5, 0x4a, 0xdb, 0x59, 0x86, 0x45, 0x2e, 0x81,
-       0x71, 0xc9, 0x47, 0xda, 0x6e, 0x69, 0xc4, 0x0c,
-       0x0f, 0xc8, 0xcb, 0xdb, 0x57, 0x34, 0xe5, 0x5c,
-       0xe0, 0xd8, 0x83, 0x0c, 0x5b, 0x9e, 0x73, 0x81,
-       0x61, 0x0f, 0xa9, 0xd8, 0xd5, 0x68, 0x14, 0xb1,
-       0x32, 0x86, 0x35, 0x5c, 0x42, 0x99, 0x97, 0xc2,
-       0xc6, 0x52, 0x59, 0x2d, 0x4c, 0x34, 0xfa, 0x7b,
-       0x9b, 0x51, 0x17, 0x90, 0x5b, 0x3b, 0x3b, 0x9a,
-       0x25, 0xac, 0xc3, 0xef, 0xed, 0x31, 0x6c, 0x5b,
-       0x34, 0xda, 0x8f, 0x23, 0x11, 0xc7, 0x3e, 0x00,
-       0xc2, 0x0c, 0xf3, 0x39, 0xf6, 0x3b, 0xcc, 0x0f,
-       0xb1, 0x05, 0x1c, 0x43, 0x99, 0x57, 0x7f, 0x8f,
-       0xb3, 0x4d, 0x8e, 0x5d, 0x24, 0xcc, 0xac, 0x62,
-       0x7d, 0x40, 0x98, 0x17, 0xb1, 0x50, 0x53, 0x47,
-       0xe8, 0x0f, 0x0c, 0x6b, 0x56, 0xb1, 0x4b, 0xc0,
-       0x65, 0x56, 0xc4, 0x38, 0x49, 0xe6, 0xc2, 0xc0,
-       0x0a, 0xa9, 0xb5, 0xe5, 0x2c, 0xc5, 0x41, 0xb1,
-       0x61, 0x64, 0x7b, 0xf0, 0x9c, 0xaa, 0x09, 0x3d,
-       0x62, 0x52, 0x5b, 0xe3, 0x39, 0x8e, 0x59, 0x10,
-       0x6b, 0x52, 0x23, 0x91, 0xb3, 0xcb, 0x90, 0x1c,
-       0xc7, 0x89, 0x58, 0x1c, 0x27, 0x62, 0x1a, 0xe7,
-       0x27, 0x57, 0xf7, 0xb9, 0x0c, 0x93, 0x9a, 0x56,
-       0x7e, 0x0c, 0x2a, 0xe6, 0x35, 0x64, 0xc4, 0x61,
-       0xdd, 0x86, 0x3b, 0x35, 0x2c, 0x7a, 0xb5, 0xaa,
-       0xce, 0x90, 0xd9, 0xd9, 0xd6, 0xfa, 0x6b, 0x8e,
-       0x79, 0xcd, 0x86, 0x7b, 0x5b, 0x5b, 0xda, 0x96,
-       0xa1, 0xaa, 0x29, 0xae, 0xda, 0x70, 0x17, 0x62,
-       0x5a, 0x9c, 0xd7, 0x90, 0x53, 0xbf, 0x2c, 0x70,
-       0x99, 0x49, 0xe9, 0x5f, 0xeb, 0x32, 0xcc, 0x08,
-       0x48, 0x0d, 0xbf, 0x56, 0xb1, 0xb0, 0x61, 0x46,
-       0x67, 0x5b, 0x80, 0x73, 0xf6, 0x57, 0xb9, 0x0c,
-       0x63, 0x43, 0x41, 0x89, 0x69, 0xfe, 0x13, 0x08,
-       0xe0, 0xdc, 0x9b, 0x1a, 0xe5, 0x13, 0x56, 0xce,
-       0xab, 0x60, 0x58, 0xdc, 0x1a, 0xe8, 0x08, 0x51,
-       0xbb, 0xa0, 0x15, 0x04, 0x0d, 0xa3, 0x78, 0x98,
-       0x61, 0x21, 0xc3, 0xa8, 0x60, 0x88, 0x19, 0x01,
-       0x7c, 0x16, 0xb5, 0x0e, 0x1a, 0xf3, 0x1b, 0xa4,
-       0x8e, 0xbc, 0x97, 0x79, 0xee, 0x2e, 0xc3, 0xed,
-       0x1d, 0x0f, 0x73, 0x99, 0xd1, 0xab, 0x15, 0x11,
-       0xc3, 0xed, 0x4d, 0x2b, 0x43, 0x67, 0x18, 0xb6,
-       0xc7, 0x1b, 0xd6, 0x21, 0x76, 0x99, 0xd7, 0xa8,
-       0xdf, 0x14, 0x31, 0x14, 0x06, 0x43, 0xbf, 0xe1,
-       0xd8, 0xb5, 0xfe, 0xd5, 0x46, 0x7f, 0x40, 0x2d,
-       0x0c, 0xb6, 0x43, 0x97, 0x71, 0x5e, 0x0c, 0xbb,
-       0x76, 0x69, 0xb5, 0xd1, 0x2d, 0xc7, 0xe2, 0x2e,
-       0x75, 0x19, 0x5d, 0x1a, 0xd6, 0x7f, 0xad, 0x7a,
-       0xc0, 0x58, 0xa4, 0xd5, 0xa1, 0x3f, 0x5a, 0x3d,
-       0x68, 0xbc, 0x47, 0xc3, 0xb0, 0x9c, 0x2b, 0x8c,
-       0x3a, 0xc4, 0x02, 0x57, 0x08, 0x9b, 0x79, 0xd9,
-       0x6e, 0xa8, 0x6c, 0x68, 0x69, 0x5b, 0xf1, 0x01,
-       0x61, 0x45, 0x38, 0x41, 0x9c, 0x43, 0xd8, 0x05,
-       0x8e, 0xd9, 0x38, 0xd6, 0xcf, 0x39, 0x8b, 0x90,
-       0x33, 0xc0, 0xcc, 0x8c, 0xe2, 0x1c, 0x18, 0x47,
-       0xd8, 0x05, 0x86, 0x39, 0x55, 0x8c, 0xf4, 0x72,
-       0xf5, 0x8a, 0x60, 0xa8, 0x22, 0x9d, 0xe5, 0xee,
-       0x46, 0xec, 0xf4, 0x15, 0x30, 0x2c, 0xd2, 0xb0,
-       0x4f, 0x8a, 0x5e, 0x31, 0xc3, 0x84, 0x86, 0xe5,
-       0x81, 0xdf, 0x70, 0xcd, 0xef, 0x03, 0x83, 0x20,
-       0xd5, 0x37, 0x9c, 0x55, 0xdb, 0x01, 0xb1, 0x0e,
-       0x0d, 0x73, 0xbe, 0x0b, 0x90, 0x26, 0x35, 0x36,
-       0x5e, 0xe5, 0xd8, 0x53, 0x88, 0x75, 0x74, 0xd6,
-       0x5f, 0xe5, 0xbd, 0x0a, 0x6d, 0x70, 0x56, 0x80,
-       0x84, 0xca, 0x67, 0x39, 0x56, 0x4e, 0xd8, 0x87,
-       0x6a, 0x9c, 0xd1, 0x17, 0x68, 0x6d, 0x97, 0xce,
-       0x6a, 0xd8, 0x6c, 0xb2, 0x64, 0xd6, 0xc3, 0x23,
-       0x7d, 0x11, 0xc3, 0xdd, 0xf5, 0x72, 0x48, 0xc5,
-       0xce, 0x33, 0xac, 0xa1, 0xf9, 0x63, 0x86, 0x5d,
-       0xe0, 0x58, 0xeb, 0x25, 0x86, 0x5d, 0x64, 0x98,
-       0xea, 0x19, 0x22, 0xe7, 0x22, 0x86, 0xec, 0x7a,
-       0x19, 0xdb, 0xec, 0xf7, 0x84, 0xfd, 0x5a, 0xc3,
-       0x7e, 0x47, 0xd8, 0x6f, 0x18, 0x26, 0xcb, 0xbf,
-       0x65, 0x9c, 0xbf, 0x8d, 0x18, 0xa6, 0xd4, 0xcb,
-       0x2d, 0x6d, 0xbf, 0x63, 0x18, 0xb6, 0x66, 0x6e,
-       0x83, 0xd4, 0xda, 0xfa, 0x1b, 0x86, 0xb9, 0x22,
-       0x86, 0x04, 0xb5, 0x98, 0x88, 0x79, 0x22, 0x86,
-       0xc9, 0x43, 0x58, 0x69, 0xc4, 0x60, 0x18, 0xc2,
-       0xca, 0x23, 0x06, 0x63, 0x0c, 0xeb, 0xaf, 0x12,
-       0x0d, 0xe3, 0x62, 0xd8, 0xb5, 0xaa, 0xd5, 0x06,
-       0x07, 0x55, 0xfd, 0x57, 0x88, 0xfd, 0x31, 0x8c,
-       0xd6, 0x93, 0x4e, 0x18, 0xe5, 0xf0, 0x49, 0x91,
-       0xce, 0xac, 0x9b, 0x48, 0x18, 0x6b, 0xb1, 0xc8,
-       0x55, 0x30, 0xde, 0x1f, 0xaa, 0xbf, 0xc0, 0x7b,
-       0x4e, 0xc4, 0x1d, 0x31, 0x58, 0x5a, 0x9b, 0x3e,
-       0x50, 0xfb, 0x9f, 0x18, 0x35, 0x4c, 0xad, 0x0f,
-       0x4a, 0x39, 0xac, 0xa5, 0xa3, 0x12, 0x61, 0x1d,
-       0x41, 0x15, 0xc3, 0x59, 0x9c, 0x89, 0xe2, 0xfe,
-       0xc0, 0xe3, 0x08, 0xc3, 0x38, 0x86, 0x01, 0xc6,
-       0x99, 0x29, 0xee, 0xcc, 0x30, 0x8c, 0xd5, 0x16,
-       0xe8, 0x94, 0x7c, 0xe2, 0x3c, 0x33, 0x0c, 0x63,
-       0x71, 0x3d, 0xfd, 0x61, 0x63, 0x4d, 0xe0, 0x8c,
-       0xea, 0x15, 0x9f, 0x43, 0xef, 0x56, 0x2b, 0xab,
-       0x58, 0x3f, 0x96, 0xc5, 0xe8, 0x54, 0x11, 0xc2,
-       0xc0, 0x98, 0x18, 0xc3, 0x30, 0x07, 0x63, 0x92,
-       0x86, 0x45, 0xaf, 0xf6, 0x7b, 0x8d, 0xd5, 0x81,
-       0xc6, 0x33, 0xaa, 0x6f, 0xed, 0x77, 0x19, 0xe7,
-       0x06, 0x7e, 0xa7, 0xc5, 0x5d, 0xf2, 0x1a, 0x3d,
-       0x72, 0x2c, 0xee, 0x92, 0xcb, 0x58, 0x22, 0xab,
-       0x71, 0xfd, 0x57, 0xab, 0x0f, 0x19, 0x6d, 0x8d,
-       0x5a, 0x7e, 0x91, 0xea, 0x88, 0x31, 0xe5, 0x77,
-       0x31, 0x0f, 0xed, 0x05, 0xc3, 0x98, 0x36, 0xd5,
-       0xea, 0x10, 0x73, 0x19, 0xc6, 0x04, 0x34, 0x2d,
-       0x45, 0x7c, 0x11, 0xc3, 0x98, 0x90, 0xa4, 0x7a,
-       0xfd, 0x48, 0x55, 0xd8, 0x30, 0x66, 0x69, 0xc7,
-       0x25, 0x0d, 0xc3, 0xb8, 0xa5, 0xcb, 0xd5, 0xd1,
-       0x22, 0x72, 0x1a, 0x31, 0x29, 0x16, 0xf7, 0x01,
-       0xc3, 0x2e, 0xa8, 0xd8, 0x19, 0xc4, 0x5a, 0x63,
-       0x71, 0xbf, 0x62, 0x98, 0x16, 0x77, 0x16, 0xb1,
-       0x60, 0xfb, 0xca, 0x4b, 0x1c, 0xfb, 0x90, 0x63,
-       0x17, 0x38, 0xf6, 0x11, 0xc3, 0xb4, 0x74, 0x1f,
-       0x33, 0x4c, 0x4b, 0xf7, 0x09, 0x96, 0x3a, 0xd0,
-       0x21, 0xa9, 0x36, 0xff, 0x09, 0x95, 0x1a, 0x07,
-       0xb2, 0x50, 0x7b, 0xf0, 0xc3, 0x68, 0xe4, 0x77,
-       0x18, 0x27, 0xc7, 0xe2, 0x7e, 0x87, 0x71, 0x72,
-       0x2c, 0xae, 0xd2, 0x65, 0x28, 0x6e, 0x6c, 0x59,
-       0xd1, 0xd9, 0xca, 0xc6, 0x23, 0xc4, 0xa6, 0x23,
-       0xd6, 0x11, 0xc3, 0xa6, 0x51, 0x1c, 0xf3, 0x9f,
-       0x84, 0xdd, 0x47, 0x71, 0x2a, 0x06, 0x86, 0x69,
-       0xcb, 0x3b, 0x5b, 0x3b, 0x63, 0xd8, 0x7d, 0x88,
-       0xb1, 0xb8, 0x4f, 0x22, 0xe1, 0x88, 0x61, 0x04,
-       0x72, 0xfe, 0x9e, 0xdb, 0xd9, 0x5a, 0x8e, 0xfd,
-       0x8e, 0x63, 0x11, 0xc4, 0x90, 0x53, 0x8d, 0xdb,
-       0xc7, 0x31, 0x35, 0xce, 0x1d, 0x36, 0x8c, 0x68,
-       0x68, 0x5e, 0xc6, 0x2c, 0x0b, 0x31, 0x30, 0xcc,
-       0x24, 0xec, 0x02, 0x6b, 0xa3, 0x8d, 0x11, 0xfd,
-       0x2d, 0xd8, 0xdf, 0x3f, 0xe0, 0x2d, 0xd6, 0x83,
-       0x18, 0x7a, 0x0d, 0x15, 0xeb, 0x45, 0x0c, 0x3d,
-       0xc3, 0x07, 0xdc, 0x43, 0x87, 0x01, 0x52, 0x55,
-       0x25, 0x21, 0xb6, 0x11, 0xb1, 0x8e, 0xce, 0x33,
-       0x2a, 0xd6, 0x83, 0x58, 0x83, 0xda, 0x46, 0x9f,
-       0x40, 0x04, 0x31, 0x89, 0x0f, 0xd3, 0x88, 0xf5,
-       0x12, 0xd6, 0xa8, 0x61, 0x6b, 0x71, 0x66, 0x33,
-       0x24, 0x05, 0xbd, 0x8d, 0x75, 0x48, 0xca, 0x2b,
-       0x88, 0x35, 0xa9, 0x91, 0x9f, 0xc0, 0x3e, 0xc4,
-       0x86, 0xa4, 0xbc, 0x4b, 0x98, 0x2a, 0x25, 0x1a,
-       0x31, 0x83, 0x61, 0x74, 0x3d, 0x77, 0x2f, 0x84,
-       0xb9, 0x10, 0xe3, 0xee, 0x85, 0xb0, 0x30, 0x61,
-       0xad, 0x6a, 0x4b, 0x9b, 0x23, 0x88, 0x71, 0xf7,
-       0x02, 0x9f, 0x22, 0x96, 0x90, 0xd7, 0xa0, 0xda,
-       0xd9, 0xa7, 0x11, 0x88, 0x98, 0x0a, 0x50, 0x13,
-       0x3b, 0x63, 0xd8, 0xd7, 0xb0, 0xee, 0x3b, 0x79,
-       0x7e, 0xd5, 0x00, 0x76, 0xac, 0xfb, 0x27, 0x1c,
-       0x9b, 0x87, 0x18, 0x6a, 0x89, 0x63, 0xf6, 0xd3,
-       0x00, 0xb7, 0x69, 0x36, 0x88, 0x98, 0x19, 0x6e,
-       0x6b, 0x1d, 0xc2, 0x6c, 0x70, 0x9b, 0x66, 0x67,
-       0x88, 0xd9, 0x09, 0xd3, 0xe2, 0x3e, 0x60, 0xe9,
-       0x2e, 0x68, 0x18, 0x4b, 0x17, 0xc3, 0x78, 0xba,
-       0x0b, 0x2a, 0xc6, 0xd2, 0xa9, 0x36, 0x48, 0x97,
-       0x5b, 0x63, 0x23, 0x3a, 0x9d, 0x96, 0x76, 0x6b,
-       0x6c, 0x44, 0xa7, 0x8f, 0x5e, 0xdc, 0x8a, 0x25,
-       0x53, 0x31, 0x13, 0xc5, 0x35, 0x6a, 0x71, 0x16,
-       0xc4, 0x62, 0xf3, 0x02, 0x9c, 0x50, 0xc2, 0xad,
-       0x58, 0x3f, 0x3e, 0xf6, 0x47, 0x74, 0x60, 0xb0,
-       0x6a, 0x1a, 0x44, 0xcc, 0x85, 0x98, 0xaa, 0x41,
-       0xc4, 0xc2, 0x84, 0x71, 0x0d, 0x22, 0x16, 0x41,
-       0x4c, 0xd5, 0x60, 0x14, 0x27, 0xa5, 0x90, 0x45,
-       0x9e, 0x8f, 0x7b, 0x22, 0x17, 0xc0, 0x98, 0xb6,
-       0x26, 0x85, 0x8f, 0x16, 0xb8, 0xd4, 0x81, 0x31,
-       0x6a, 0x32, 0xc4, 0x4a, 0x59, 0x9c, 0x3a, 0x83,
-       0x80, 0x72, 0xc2, 0xda, 0xd5, 0xd1, 0x17, 0x7c,
-       0x88, 0xa9, 0x99, 0x93, 0xb5, 0x80, 0xf1, 0x0e,
-       0x92, 0xf9, 0x32, 0xf3, 0x44, 0xcf, 0x81, 0x41,
-       0x8f, 0xf3, 0x89, 0xa6, 0x29, 0x1f, 0x10, 0xd6,
-       0xaf, 0x61, 0xea, 0x54, 0xcf, 0xa0, 0x6f, 0x6c,
-       0x60, 0x86, 0x0c, 0x92, 0x8f, 0x3d, 0x5b, 0xd5,
-       0x89, 0x1e, 0x29, 0x4f, 0x0d, 0xd1, 0x9d, 0xad,
-       0x0c, 0xef, 0xc7, 0xa7, 0x21, 0x04, 0x7d, 0x5b,
-       0xc4, 0x82, 0x18, 0xa6, 0x3b, 0xbd, 0x45, 0xcc,
-       0x8c, 0x61, 0x06, 0xaf, 0x4b, 0xb4, 0xc7, 0xb0,
-       0x84, 0x0f, 0xba, 0xd9, 0x33, 0x4e, 0x8e, 0x25,
-       0x9e, 0xdb, 0x12, 0x1c, 0xb5, 0xdf, 0x65, 0xfb,
-       0xa3, 0xcd, 0x4a, 0x27, 0x56, 0x54, 0x9e, 0x02,
-       0x5c, 0x53, 0x38, 0x73, 0xf3, 0xf2, 0x0b, 0xbe,
-       0x56, 0x78, 0x4f, 0xd1, 0xbd, 0x38, 0x86, 0x36,
-       0x36, 0xc9, 0xde, 0x8f, 0xfb, 0x21, 0x94, 0xd4,
-       0xb3, 0xae, 0x81, 0x56, 0x89, 0x19, 0x1e, 0x83,
-       0x96, 0x4a, 0x36, 0xfb, 0x70, 0x85, 0xed, 0x33,
-       0x28, 0xa6, 0xea, 0x37, 0x50, 0xc2, 0x61, 0xfa,
-       0x16, 0x05, 0x4a, 0x18, 0x45, 0x6b, 0x00, 0xfa,
-       0xaa, 0x98, 0xa1, 0x8f, 0xaf, 0xb6, 0xd8, 0x19,
-       0xa5, 0x83, 0xd0, 0xa8, 0xae, 0xbd, 0x5c, 0xa2,
-       0x7e, 0x2a, 0xe0, 0xaa, 0xb3, 0xa1, 0x41, 0x1f,
-       0x68, 0xa0, 0x15, 0x1c, 0xed, 0x15, 0x11, 0xad,
-       0x53, 0x21, 0x30, 0x2a, 0xf2, 0x5d, 0x0a, 0x2b,
-       0x26, 0x8d, 0x93, 0x43, 0x81, 0xbf, 0x05, 0xe0,
-       0x2a, 0x19, 0x80, 0xac, 0x60, 0x92, 0xc7, 0x18,
-       0x72, 0x66, 0xde, 0xd6, 0xf3, 0x68, 0x93, 0xb9,
-       0xfa, 0xc0, 0xc6, 0x47, 0xfd, 0x7a, 0x91, 0xbe,
-       0x3c, 0x6a, 0xa4, 0x2f, 0x8e, 0xda, 0xf6, 0xcf,
-       0x7b, 0x33, 0x7a, 0x96, 0x7f, 0x15, 0xe9, 0xcb,
-       0x7e, 0x13, 0x49, 0xfd, 0xee, 0x44, 0xb2, 0x64,
-       0x95, 0x2c, 0xd5, 0x07, 0xb4, 0x77, 0x0e, 0x3e,
-       0xd8, 0x92, 0x06, 0x32, 0xc9, 0x4c, 0xab, 0x3e,
-       0x10, 0x4a, 0x0c, 0x3a, 0xdf, 0x33, 0x34, 0xea,
-       0x83, 0xb9, 0x36, 0x7a, 0xf7, 0xe7, 0x32, 0xdd,
-       0x6b, 0x64, 0x7b, 0x1f, 0x2e, 0x0a, 0xb3, 0x25,
-       0xd8, 0x50, 0x9d, 0xe9, 0xad, 0x3c, 0xf5, 0x30,
-       0x3b, 0xa7, 0xb2, 0xa7, 0xa3, 0xa5, 0xad, 0xa1,
-       0xfd, 0x77, 0x76, 0xa9, 0x9e, 0xac, 0xa5, 0xae,
-       0x83, 0xc1, 0x25, 0x8d, 0x0c, 0x8c, 0x93, 0x30,
-       0x06, 0x60, 0x3b, 0xef, 0xd3, 0x67, 0x3a, 0x18,
-       0xfc, 0xa8, 0x91, 0x01, 0xab, 0xd4, 0xd1, 0x72,
-       0x11, 0xcb, 0x23, 0x85, 0x24, 0x04, 0x23, 0x11,
-       0xb4, 0xf5, 0xc1, 0x1e, 0xee, 0x5f, 0xee, 0x60,
-       0xc9, 0xe0, 0xb6, 0x86, 0x76, 0x9a, 0x25, 0x3f,
-       0xd7, 0xd8, 0x42, 0xd3, 0xab, 0xd3, 0x1d, 0x0c,
-       0x9e, 0x6d, 0x64, 0xc0, 0xd6, 0x14, 0x6a, 0x47,
-       0x8b, 0x1c, 0xaf, 0x34, 0x85, 0x9a, 0x56, 0xf6,
-       0x4f, 0x40, 0xb0, 0x5c, 0xba, 0xa8, 0x6b, 0x69,
-       0x23, 0x73, 0x33, 0xb4, 0xb4, 0x85, 0x82, 0x03,
-       0x70, 0x4b, 0x6b, 0xbb, 0x92, 0xdb, 0x03, 0x69,
-       0x08, 0xb0, 0xbf, 0xa7, 0x22, 0xc0, 0x8c, 0x4c,
-       0x08, 0xda, 0x02, 0xaf, 0x6c, 0x5b, 0xde, 0x4e,
-       0x45, 0x0a, 0xf3, 0x99, 0x40, 0xa4, 0x83, 0xc1,
-       0x03, 0x8d, 0x0c, 0xfc, 0xc3, 0xf2, 0x4e, 0xea,
-       0x94, 0xbf, 0xea, 0x60, 0xf0, 0xe3, 0x46, 0x06,
-       0xc6, 0x72, 0x2b, 0x5f, 0xdc, 0xc1, 0xe0, 0x83,
-       0x8d, 0x0c, 0xfc, 0xaf, 0x20, 0x9b, 0x2a, 0xbc,
-       0xd0, 0x81, 0xd3, 0x92, 0x0f, 0xe1, 0xf9, 0x0e,
-       0xa5, 0x15, 0xcb, 0xf6, 0x8f, 0x08, 0x30, 0x49,
-       0x32, 0xab, 0x1e, 0xe8, 0x51, 0x3d, 0x58, 0x07,
-       0x63, 0xc7, 0xd7, 0x83, 0x58, 0x34, 0x77, 0x07,
-       0x83, 0x65, 0x8d, 0x0c, 0xec, 0xe0, 0x5e, 0xb1,
-       0xaf, 0x83, 0xc1, 0x0b, 0x8d, 0x0c, 0x8c, 0x62,
-       0xfa, 0x80, 0x24, 0xa6, 0x0f, 0x48, 0x09, 0x35,
-       0xb5, 0x61, 0x45, 0xa7, 0xf1, 0x7e, 0x34, 0x3a,
-       0xf4, 0x70, 0x3b, 0x55, 0x3b, 0x04, 0x32, 0x34,
-       0xb7, 0xb4, 0x76, 0x34, 0x34, 0x34, 0x60, 0x79,
-       0x9a, 0xbe, 0xbe, 0xa2, 0x61, 0x45, 0x47, 0xa0,
-       0x75, 0x79, 0x8b, 0xd2, 0xd4, 0x1a, 0x52, 0x42,
-       0xad, 0x4d, 0xf5, 0x38, 0xf1, 0x6b, 0xed, 0x68,
-       0x6d, 0xe8, 0xe8, 0xc0, 0x92, 0x75, 0x48, 0x0d,
-       0x0f, 0x77, 0x3c, 0xdc, 0xd0, 0xd2, 0xd1, 0xd2,
-       0xa0, 0x74, 0x28, 0x98, 0xa2, 0xa1, 0x41, 0x46,
-       0x59, 0x4d, 0x5f, 0x07, 0x68, 0x57, 0x42, 0xf8,
-       0x6b, 0x82, 0xf6, 0x56, 0x84, 0xad, 0x08, 0x95,
-       0x56, 0x68, 0x0f, 0x02, 0x74, 0xb6, 0xe1, 0x0f,
-       0x19, 0x3a, 0x31, 0xbe, 0x13, 0xe3, 0x3b, 0x31,
-       0xbe, 0x13, 0xe3, 0xdb, 0x9a, 0x00, 0xf3, 0x06,
-       0xe8, 0x40, 0x01, 0x1d, 0x18, 0x8f, 0xd1, 0x80,
-       0xd1, 0x80, 0xd1, 0x80, 0xd1, 0x80, 0xc9, 0xf1,
-       0x87, 0x7c, 0x0a, 0x6d, 0xbd, 0x69, 0x85, 0x36,
-       0x0a, 0x63, 0x64, 0x9b, 0x42, 0xb4, 0x10, 0x60,
-       0x61, 0xa1, 0x03, 0x79, 0x73, 0x7f, 0x5a, 0x7d,
-       0xae, 0x12, 0x1b, 0xc7, 0xe9, 0xc8, 0xfb, 0xde,
-       0x87, 0x18, 0xc8, 0x73, 0x34, 0x7d, 0x8f, 0xe3,
-       0x4d, 0xdf, 0x73, 0xe6, 0xf4, 0xb4, 0xb6, 0x21,
-       0x1d, 0x2f, 0xb9, 0xce, 0xef, 0xbd, 0x92, 0xdb,
-       0x93, 0xeb, 0xec, 0xe9, 0xec, 0xe8, 0xcf, 0x6e,
-       0x68, 0xb8, 0x94, 0xdd, 0x71, 0x69, 0x72, 0xf6,
-       0x94, 0x1d, 0x93, 0xef, 0xce, 0xde, 0x61, 0x36,
-       0x07, 0x1a, 0x82, 0x60, 0x4e, 0xec, 0x08, 0x06,
-       0xc0, 0x6c, 0xea, 0xa4, 0x6b, 0xc2, 0xf2, 0xe5,
-       0x9d, 0x41, 0xb3, 0xb1, 0xa5, 0x03, 0xc3, 0x86,
-       0xe5, 0x74, 0xd5, 0x37, 0x48, 0x52, 0xd0, 0xac,
-       0x5b, 0x51, 0x8f, 0x9c, 0xd0, 0x89, 0x14, 0x30,
-       0xd7, 0x77, 0x76, 0x04, 0x21, 0xb1, 0x31, 0x14,
-       0xca, 0x05, 0x13, 0x5e, 0x9d, 0x90, 0xd0, 0x42,
-       0x61, 0x63, 0x0b, 0x85, 0x0d, 0xa1, 0x06, 0x6a,
-       0xb1, 0x06, 0x09, 0x45, 0xeb, 0x1a, 0xe5, 0x06,
-       0x56, 0xd3, 0x06, 0x08, 0x9b, 0x43, 0xa1, 0x1e,
-       0x6b, 0x28, 0xf4, 0x8a, 0x2b, 0xf4, 0xab, 0xd2,
-       0xc6, 0x60, 0xbf, 0xb7, 0x23, 0xd8, 0x5f, 0xd9,
-       0x10, 0xec, 0xaf, 0x6e, 0x90, 0x2e, 0xd4, 0x75,
-       0x34, 0xfc, 0x6a, 0x89, 0xf4, 0x2b, 0x11, 0xf3,
-       0xee, 0xb8, 0x24, 0x06, 0x3a, 0x2e, 0x35, 0x06,
-       0x1a, 0x3a, 0x2e, 0xbd, 0xb4, 0x02, 0x17, 0xc4,
-       0x59, 0xf5, 0xad, 0x0f, 0x1b, 0x40, 0x1f, 0x7b,
-       0x37, 0x22, 0xe1, 0xab, 0xfd, 0xe8, 0x5f, 0xfd,
-       0x7d, 0xfe, 0xc9, 0x05, 0x8f, 0xd0, 0x57, 0xbf,
-       0xb6, 0xf5, 0x86, 0x69, 0x4f, 0xe6, 0x88, 0xbc,
-       0x0c, 0xaf, 0x6f, 0xac, 0xf6, 0x85, 0xdf, 0x11,
-       0x85, 0x59, 0xde, 0x57, 0x3e, 0x25, 0x58, 0x6f,
-       0x67, 0x5f, 0xb8, 0x5f, 0x5c, 0xdf, 0x8f, 0x57,
-       0x77, 0xd3, 0x79, 0x73, 0x04, 0x12, 0x46, 0xbb,
-       0x70, 0x8d, 0x71, 0xba, 0x62, 0xe0, 0x62, 0x50,
-       0x98, 0x53, 0x72, 0x01, 0x4c, 0xb6, 0xd1, 0x74,
-       0x5a, 0x55, 0x8f, 0x5d, 0x06, 0xdd, 0x52, 0xf6,
-       0x7c, 0xfe, 0x22, 0xed, 0x94, 0x1d, 0x31, 0xc3,
-       0xf3, 0x2a, 0x5e, 0xa7, 0x79, 0x16, 0x79, 0xe6,
-       0x39, 0xb3, 0xe9, 0xe4, 0xec, 0x44, 0xe8, 0xe9,
-       0x32, 0x82, 0x02, 0xba, 0x8c, 0x9e, 0x2e, 0x03,
-       0x41, 0x93, 0xd5, 0x0e, 0x39, 0x98, 0xaa, 0xc0,
-       0xe7, 0x92, 0x0b, 0xf9, 0x6e, 0x2c, 0xa4, 0xd4,
-       0x2b, 0xe8, 0x99, 0xfc, 0x0c, 0xcb, 0xdb, 0x0b,
-       0x2e, 0xab, 0x03, 0x1e, 0x8e, 0xd2, 0x69, 0xa6,
-       0xc7, 0x63, 0xb4, 0x30, 0xd2, 0x5a, 0x19, 0xed,
-       0x40, 0x0f, 0xed, 0x2e, 0x9b, 0xe6, 0x51, 0x63,
-       0xf4, 0xa0, 0xa6, 0x7f, 0x49, 0xe3, 0x35, 0x42,
-       0x2c, 0xfd, 0x16, 0x8d, 0x66, 0x82, 0x58, 0xfa,
-       0xc7, 0x7a, 0x68, 0x4f, 0x9a, 0x33, 0x2e, 0xef,
-       0x80, 0x7f, 0x48, 0x16, 0x4f, 0xf9, 0xe0, 0x30,
-       0x59, 0x94, 0xae, 0x92, 0xf6, 0x8e, 0xc8, 0x82,
-       0xf6, 0x5c, 0x0d, 0xd3, 0x3d, 0xac, 0x14, 0x0d,
-       0x2b, 0x31, 0x71, 0x65, 0xf6, 0xd0, 0xde, 0xb6,
-       0x05, 0xc3, 0xb8, 0x52, 0x34, 0x2e, 0x9d, 0x2a,
-       0x4b, 0x2e, 0xb4, 0xda, 0x40, 0x90, 0x9d, 0x7e,
-       0x4d, 0xdf, 0xf4, 0xdd, 0x75, 0x41, 0xe9, 0xaf,
-       0xfe, 0x59, 0xa6, 0x97, 0xb4, 0xe6, 0x0d, 0xf7,
-       0xba, 0xdc, 0x03, 0xb0, 0xc0, 0xe9, 0x04, 0xda,
-       0xa5, 0x99, 0x5c, 0x85, 0x53, 0x62, 0x5f, 0xa2,
-       0x9c, 0xec, 0x49, 0xf4, 0x6d, 0x56, 0xc6, 0x57,
-       0x5c, 0x80, 0x64, 0x11, 0xae, 0xd1, 0x59, 0xc6,
-       0xdb, 0x47, 0xb8, 0xf2, 0x6c, 0xeb, 0x5a, 0x41,
-       0xef, 0x5c, 0x4b, 0x67, 0x2e, 0x3e, 0xc2, 0xf6,
-       0xbc, 0x89, 0x57, 0x98, 0xf4, 0x64, 0xbf, 0x97,
-       0x87, 0x14, 0x23, 0x85, 0x78, 0x4e, 0xea, 0x19,
-       0x05, 0x7a, 0x9c, 0x7a, 0x09, 0x30, 0x0d, 0x36,
-       0xc0, 0x0a, 0x9c, 0x14, 0xbd, 0xa7, 0x4b, 0xd1,
-       0x65, 0xe8, 0x0a, 0x74, 0xc5, 0xba, 0x5a, 0xdd,
-       0x83, 0x46, 0x30, 0xda, 0x8d, 0xa5, 0xc6, 0x4a,
-       0x5d, 0xb6, 0x71, 0xfd, 0x88, 0xb7, 0x8d, 0x4f,
-       0x1a, 0x9f, 0x35, 0x1e, 0x34, 0x5e, 0x4b, 0x18,
-       0x9b, 0x30, 0xde, 0x9c, 0x6e, 0xde, 0x34, 0xe2,
-       0xf9, 0x11, 0x6f, 0x5b, 0x4d, 0xd6, 0xc5, 0x23,
-       0xb3, 0x47, 0x3a, 0x47, 0x16, 0x8c, 0x2c, 0x1a,
-       0xe9, 0x35, 0xe9, 0xa1, 0xc0, 0x58, 0x6d, 0xda,
-       0x6d, 0x5a, 0x6d, 0xda, 0x92, 0x98, 0x09, 0x07,
-       0x61, 0xa7, 0x79, 0xbf, 0xf9, 0xbd, 0x24, 0x7b,
-       0xd2, 0xe6, 0xa4, 0xad, 0x49, 0xbb, 0x2d, 0xb6,
-       0xa4, 0xf7, 0x46, 0x4e, 0x1b, 0xb1, 0x74, 0x44,
-       0xe3, 0x08, 0xe7, 0x88, 0xac, 0xc4, 0x3c, 0xdd,
-       0x58, 0x4b, 0x5e, 0xd2, 0x11, 0xc3, 0x15, 0xe3,
-       0x34, 0x8b, 0xc7, 0x90, 0x95, 0xb0, 0x34, 0xc1,
-       0x67, 0x29, 0xb7, 0x2c, 0xb1, 0xbc, 0x66, 0xe9,
-       0x4b, 0xd8, 0x9b, 0x70, 0x26, 0x71, 0xa5, 0xb1,
-       0xc0, 0xd0, 0x6f, 0xc9, 0x4e, 0x3a, 0x88, 0x53,
-       0xbc, 0x4a, 0xcb, 0x02, 0x4b, 0xa5, 0x65, 0x7c,
-       0xc2, 0x85, 0xc4, 0xad, 0xba, 0x36, 0xdd, 0x4a,
-       0xbd, 0x49, 0xbf, 0x4e, 0xbf, 0x46, 0x6f, 0xa1,
-       0x67, 0xb3, 0x7f, 0x38, 0x4d, 0xdf, 0x12, 0x19,
-       0xe1, 0xaa, 0xea, 0xd4, 0x76, 0xf3, 0x25, 0x1f,
-       0x75, 0x0f, 0x0c, 0x94, 0x89, 0x90, 0x1c, 0x1a,
-       0xda, 0xfb, 0x93, 0xfc, 0x3a, 0xd2, 0xbe, 0x86,
-       0x34, 0x11, 0x61, 0x16, 0xed, 0x37, 0x1d, 0x70,
-       0x20, 0xd5, 0x8f, 0x94, 0x67, 0xe8, 0xec, 0x6f,
-       0xba, 0x43, 0x3a, 0xf2, 0xd2, 0xda, 0x55, 0x24,
-       0xc9, 0x7a, 0x3b, 0xd9, 0xe4, 0x7b, 0xdd, 0x08,
-       0x1f, 0x56, 0xd2, 0xcd, 0x9f, 0xe2, 0xe4, 0x77,
-       0xfb, 0x08, 0xb7, 0xf5, 0x6e, 0xd6, 0xa6, 0x55,
-       0x62, 0x11, 0x72, 0x6e, 0x64, 0x3c, 0x39, 0xc4,
-       0x21, 0x93, 0x9c, 0x52, 0x2c, 0x47, 0xdd, 0xfc,
-       0xf0, 0x46, 0x66, 0xef, 0xec, 0x9a, 0x97, 0x0e,
-       0x4b, 0xf5, 0xe5, 0x6b, 0x77, 0xee, 0x05, 0x78,
-       0x24, 0x5a, 0x6f, 0x14, 0x61, 0xe4, 0xa0, 0x87,
-       0x7d, 0x63, 0x76, 0x64, 0x2d, 0x4b, 0x7b, 0x09,
-       0xaf, 0xad, 0xf2, 0x05, 0x4c, 0x6b, 0xc6, 0xb4,
-       0xe3, 0xd4, 0xb4, 0x79, 0xc8, 0xf7, 0x11, 0xf2,
-       0x38, 0xb9, 0xfc, 0x40, 0xfd, 0xc6, 0xdb, 0xd9,
-       0xfb, 0xef, 0xbf, 0x95, 0xd3, 0x91, 0xfa, 0xbe,
-       0x04, 0x57, 0x2e, 0x69, 0x9c, 0x6b, 0xef, 0xa5,
-       0x52, 0x29, 0x16, 0xcc, 0x25, 0x1c, 0x7c, 0xa4,
-       0x67, 0x6d, 0x83, 0x5e, 0x95, 0x7f, 0x4c, 0x04,
-       0xeb, 0x8c, 0x9b, 0xed, 0x7f, 0x1a, 0xf9, 0x1a,
-       0xc6, 0x14, 0x4a, 0x60, 0x9d, 0x86, 0xb9, 0xbc,
-       0x80, 0x39, 0x4c, 0x92, 0xe1, 0x5f, 0xb6, 0xa3,
-       0xcc, 0x67, 0x31, 0xee, 0x41, 0xf7, 0xc0, 0xa7,
-       0xa3, 0x91, 0xee, 0x92, 0xcc, 0x18, 0x1a, 0x81,
-       0xa1, 0x42, 0x95, 0x23, 0x8c, 0x1c, 0x5d, 0x88,
-       0x17, 0x3b, 0x8b, 0x75, 0x11, 0xe4, 0xcc, 0x11,
-       0x3f, 0x0a, 0x40, 0xb0, 0x73, 0xd3, 0xed, 0x8a,
-       0xf5, 0x68, 0x31, 0x5c, 0x43, 0x8e, 0x07, 0xd1,
-       0x27, 0x8c, 0xb0, 0x8e, 0x81, 0x36, 0xd9, 0x84,
-       0x21, 0x8b, 0x7f, 0x36, 0xd7, 0xe0, 0xbf, 0x94,
-       0x07, 0xeb, 0x91, 0x2b, 0x0d, 0x69, 0xa6, 0x9d,
-       0xc5, 0xf0, 0x6b, 0xc5, 0x8a, 0xd7, 0x2b, 0x48,
-       0xcf, 0xc1, 0x09, 0x21, 0x4a, 0xb2, 0x9e, 0xa5,
-       0x73, 0x24, 0x91, 0xb7, 0x51, 0xb6, 0x4b, 0x30,
-       0xe2, 0x02, 0x86, 0xa6, 0x61, 0x2c, 0x9d, 0x5e,
-       0x96, 0xce, 0x6a, 0x57, 0x22, 0x26, 0xd7, 0xe0,
-       0xcc, 0x6f, 0xa4, 0x1e, 0xdb, 0x00, 0x67, 0x74,
-       0x23, 0x3c, 0xc8, 0x91, 0x2d, 0xc3, 0xb1, 0x8b,
-       0xc8, 0x01, 0xe7, 0xea, 0x18, 0x8f, 0x87, 0x9e,
-       0xa1, 0xd0, 0x57, 0x53, 0x50, 0xde, 0x66, 0x2c,
-       0x43, 0xa3, 0x92, 0x86, 0x57, 0x99, 0x9d, 0x07,
-       0x79, 0x58, 0xe5, 0x7f, 0x5d, 0x04, 0x5d, 0x91,
-       0x99, 0xce, 0x4e, 0x45, 0x7e, 0x09, 0x74, 0xd9,
-       0x18, 0xf7, 0x42, 0xa0, 0x28, 0xc2, 0x5a, 0x5b,
-       0x81, 0x63, 0xcf, 0xd2, 0x5b, 0xf1, 0x08, 0xe9,
-       0x7d, 0xf5, 0x62, 0x84, 0x4f, 0xb2, 0xf7, 0xd6,
-       0xc7, 0xa7, 0xb0, 0x32, 0x04, 0x12, 0xcf, 0x24,
-       0xfd, 0x2a, 0x85, 0x4e, 0x17, 0x19, 0xb3, 0x9f,
-       0x70, 0xf3, 0xab, 0xf4, 0x5d, 0x1d, 0xca, 0x97,
-       0xef, 0x1c, 0x5c, 0x09, 0xce, 0xe2, 0x30, 0xe5,
-       0x9e, 0xa6, 0xe9, 0xdc, 0xbb, 0x1a, 0x96, 0x52,
-       0x19, 0xe4, 0xe4, 0x58, 0x9e, 0xd8, 0x47, 0xad,
-       0x05, 0xc8, 0x53, 0xc4, 0x4a, 0xd4, 0x86, 0x57,
-       0x59, 0x6e, 0xc6, 0x6b, 0x40, 0xae, 0x0f, 0x59,
-       0x91, 0xb7, 0x41, 0x49, 0x0b, 0x91, 0x06, 0x3b,
-       0x94, 0xe4, 0x10, 0x69, 0xa4, 0x45, 0xf6, 0x21,
-       0x26, 0xc9, 0xa5, 0x4c, 0x97, 0x41, 0xb9, 0x38,
-       0x81, 0x7a, 0xac, 0xc7, 0x6f, 0x44, 0xea, 0x54,
-       0x5c, 0x0d, 0x24, 0x28, 0x59, 0xfe, 0xd9, 0xe2,
-       0x1e, 0xac, 0x77, 0x51, 0x84, 0xd9, 0x81, 0x4c,
-       0xbb, 0x38, 0x75, 0x72, 0xea, 0x3c, 0x90, 0x53,
-       0x58, 0x88, 0x7f, 0xa7, 0x07, 0xd3, 0xc8, 0xcc,
-       0x2e, 0x78, 0x5b, 0xfe, 0x62, 0x97, 0x04, 0x97,
-       0x7b, 0x94, 0xf1, 0x58, 0xbf, 0x99, 0xf5, 0xf0,
-       0x8b, 0x17, 0xf8, 0x4e, 0xc1, 0x5f, 0x50, 0xfd,
-       0x47, 0x35, 0x98, 0x69, 0x17, 0x21, 0x62, 0x1b,
-       0xc3, 0x5d, 0x4b, 0xe8, 0xbc, 0xe6, 0x4a, 0x11,
-       0x2c, 0x41, 0x67, 0x71, 0x2f, 0x90, 0x56, 0x65,
-       0xbb, 0x7f, 0xb6, 0xed, 0xf6, 0x8d, 0xc4, 0xb1,
-       0x02, 0xf9, 0x12, 0xeb, 0x03, 0xe7, 0xcc, 0xd4,
-       0xea, 0xa2, 0xc8, 0xea, 0x52, 0xcf, 0xea, 0xb2,
-       0x24, 0xe5, 0xf6, 0x4d, 0xc4, 0x51, 0xbb, 0x93,
-       0x38, 0xaa, 0x56, 0x24, 0x3e, 0xad, 0x4b, 0x8c,
-       0x60, 0xea, 0x6c, 0x65, 0x1a, 0xc6, 0x4f, 0x55,
-       0x8e, 0x61, 0x1f, 0x9a, 0x82, 0x1e, 0x2f, 0x9b,
-       0xa5, 0xc9, 0x61, 0x69, 0x1c, 0xa9, 0xb7, 0x6f,
-       0xa6, 0x34, 0xc2, 0x2e, 0x4a, 0x33, 0x76, 0x97,
-       0xae, 0x21, 0xcd, 0xaf, 0xe3, 0x29, 0x77, 0xe9,
-       0xe4, 0xcb, 0x62, 0x84, 0xf5, 0x49, 0x0f, 0xed,
-       0x6f, 0x3d, 0x7a, 0x45, 0x02, 0x4b, 0x17, 0xf5,
-       0x54, 0x8b, 0x17, 0x7f, 0x2f, 0xb0, 0x10, 0x9d,
-       0x37, 0x79, 0x50, 0x82, 0x24, 0xb2, 0xe7, 0x6c,
-       0x05, 0x06, 0x57, 0x0e, 0xd5, 0xf6, 0x28, 0xd2,
-       0x7f, 0xb7, 0x1f, 0x4b, 0x3b, 0xa1, 0x1e, 0x8e,
-       0xbe, 0x86, 0x7c, 0x21, 0xac, 0xd1, 0xcb, 0x08,
-       0x8b, 0x58, 0x4a, 0xfa, 0xb1, 0xa7, 0x29, 0x49,
-       0xfb, 0x31, 0xb4, 0x0e, 0xe3, 0xb6, 0x22, 0xac,
-       0x5e, 0x01, 0x58, 0xca, 0x6c, 0xd0, 0xcb, 0x36,
-       0xf3, 0x1b, 0x30, 0x02, 0xad, 0x65, 0xc0, 0x8f,
-       0x36, 0x68, 0x59, 0x23, 0xa2, 0x45, 0x59, 0x56,
-       0x72, 0x8b, 0x3a, 0xda, 0x4a, 0x67, 0x25, 0xe6,
-       0xbf, 0xc1, 0x4b, 0x86, 0x74, 0x51, 0x04, 0xf3,
-       0x61, 0xac, 0x29, 0xe5, 0x5a, 0x4d, 0x52, 0x50,
-       0x5a, 0xa9, 0x5a, 0x0a, 0x17, 0x96, 0x02, 0xad,
-       0xea, 0x68, 0x11, 0x59, 0x19, 0x96, 0xc4, 0x89,
-       0x2d, 0x02, 0xbd, 0xc0, 0xac, 0xd7, 0x85, 0x7c,
-       0xe3, 0x18, 0x9f, 0x80, 0x5c, 0x69, 0xc8, 0x95,
-       0xa2, 0x72, 0x59, 0x86, 0x73, 0x99, 0x5f, 0x57,
-       0x6d, 0xc9, 0x4d, 0x3d, 0xc2, 0xbc, 0x12, 0x29,
-       0x2f, 0x71, 0xf9, 0xef, 0x9e, 0x96, 0xe0, 0xd2,
-       0x49, 0xbe, 0xf7, 0xf3, 0xdd, 0x63, 0xdc, 0x2b,
-       0x90, 0xb6, 0xcc, 0x9b, 0xdd, 0x03, 0xbf, 0x2f,
-       0x26, 0x2b, 0x52, 0x52, 0x30, 0xad, 0x81, 0xe8,
-       0x52, 0x2a, 0x95, 0x1f, 0xe3, 0x64, 0xda, 0x85,
-       0xc9, 0xeb, 0xf2, 0xee, 0x73, 0x22, 0x24, 0xf9,
-       0x9c, 0xf4, 0x1d, 0x33, 0xf6, 0x35, 0xb7, 0x11,
-       0x1e, 0xb6, 0x57, 0xcf, 0x3a, 0xb4, 0x57, 0xef,
-       0xdd, 0x35, 0x58, 0xc7, 0xcc, 0xcc, 0x0a, 0xdf,
-       0xcf, 0x94, 0x64, 0x7a, 0x13, 0x09, 0x35, 0x96,
-       0x25, 0xa5, 0x61, 0xaa, 0x7a, 0xea, 0x75, 0x49,
-       0xe3, 0xf1, 0x27, 0xaa, 0xb2, 0x6a, 0x31, 0xcf,
-       0x59, 0xe9, 0xb3, 0x53, 0xec, 0x0a, 0xbc, 0xeb,
-       0x0d, 0x3c, 0x12, 0xb1, 0xf5, 0xdc, 0x2e, 0x9b,
-       0x7c, 0xf6, 0xa5, 0x97, 0x45, 0x33, 0x5e, 0x07,
-       0x33, 0x2b, 0xc4, 0xb3, 0x8f, 0xaa, 0xbd, 0x36,
-       0xe5, 0x76, 0x4c, 0xd3, 0x20, 0xdb, 0x02, 0x06,
-       0xf7, 0xc0, 0x71, 0xef, 0x4e, 0x3a, 0x3d, 0xd4,
-       0x4c, 0x7b, 0xb3, 0x45, 0x78, 0x37, 0xf9, 0x37,
-       0x5e, 0xee, 0x89, 0x31, 0xdf, 0xe3, 0x5c, 0x72,
-       0xef, 0x00, 0x42, 0x07, 0xc2, 0x4b, 0xd8, 0xf7,
-       0x77, 0x60, 0x78, 0x32, 0x86, 0x3f, 0xaa, 0xea,
-       0x5c, 0x41, 0xd6, 0x19, 0x52, 0xec, 0xb1, 0x36,
-       0xe3, 0x9e, 0xc2, 0x2d, 0x79, 0xb0, 0xd5, 0x52,
-       0x45, 0xab, 0x64, 0x53, 0xd3, 0xbf, 0x26, 0x39,
-       0x9d, 0x06, 0xac, 0xf9, 0x8a, 0xb2, 0x81, 0xcb,
-       0x79, 0x4b, 0x7c, 0xbe, 0x94, 0x65, 0xe3, 0x82,
-       0x60, 0xcb, 0xb3, 0xe9, 0x95, 0xe4, 0x9e, 0x7c,
-       0x1b, 0xc8, 0x17, 0xfc, 0x3a, 0xb4, 0x5a, 0xa3,
-       0x7c, 0x61, 0xbd, 0xff, 0xbd, 0x7d, 0xdc, 0xa7,
-       0xd8, 0x6e, 0x47, 0xad, 0x36, 0x2a, 0x16, 0xb4,
-       0x83, 0x51, 0xec, 0x9c, 0x92, 0xf3, 0x12, 0xe8,
-       0x37, 0xf6, 0xd5, 0xad, 0xa7, 0x72, 0x4d, 0x53,
-       0xe5, 0xd6, 0x33, 0xff, 0x05, 0xbd, 0x8b, 0x57,
-       0x80, 0x74, 0xfa, 0x5b, 0xaa, 0xad, 0xaa, 0xb4,
-       0x72, 0xa4, 0x1d, 0x51, 0xf9, 0xa6, 0x49, 0x66,
-       0x2d, 0x56, 0xdd, 0x2f, 0x4b, 0xbd, 0xe0, 0x1b,
-       0x18, 0x23, 0x48, 0x0e, 0xda, 0xfd, 0xf0, 0x1b,
-       0x6f, 0x01, 0x70, 0x0f, 0xd8, 0x9b, 0x2c, 0xa5,
-       0x11, 0x25, 0x4c, 0xfe, 0xee, 0xaf, 0x64, 0x78,
-       0xe7, 0x1a, 0x1b, 0xe1, 0x48, 0x2e, 0xf3, 0x6f,
-       0x12, 0xf4, 0x5f, 0x50, 0xe0, 0x9d, 0x3e, 0xf2,
-       0x52, 0xf5, 0xf0, 0xce, 0x69, 0x9c, 0x7b, 0x25,
-       0x54, 0x75, 0xc6, 0xfa, 0x27, 0xbc, 0xf3, 0x36,
-       0xeb, 0xa1, 0xf0, 0xce, 0x41, 0x9a, 0xab, 0x69,
-       0xbd, 0xe1, 0x9d, 0x3d, 0x22, 0x98, 0xba, 0x51,
-       0xc2, 0x14, 0x39, 0x9b, 0x79, 0x15, 0xd4, 0xe6,
-       0x3b, 0xcf, 0x4b, 0x60, 0x5a, 0xec, 0x1e, 0xf8,
-       0x1d, 0xed, 0xe1, 0xa5, 0xbd, 0xa1, 0xc9, 0x5c,
-       0xb3, 0xef, 0x3c, 0xa1, 0x59, 0x0c, 0xed, 0x1a,
-       0x34, 0xf9, 0x24, 0x48, 0xb8, 0xc6, 0xeb, 0xf1,
-       0x4e, 0x50, 0x84, 0x4f, 0xfb, 0xd4, 0xd4, 0x68,
-       0x45, 0xa6, 0x71, 0xee, 0x81, 0x4b, 0x67, 0x69,
-       0xdf, 0x2a, 0xf6, 0x88, 0xfa, 0xbe, 0x3a, 0xfa,
-       0x96, 0xab, 0x08, 0x89, 0x16, 0x6c, 0x0f, 0x24,
-       0xc8, 0xd5, 0x2a, 0x67, 0x31, 0x4a, 0xb8, 0xa4,
-       0xca, 0x76, 0x06, 0xa9, 0x9e, 0x77, 0x2b, 0xc6,
-       0x9a, 0xd9, 0x41, 0xb5, 0x75, 0xde, 0x19, 0xc7,
-       0xac, 0xc2, 0x3d, 0x93, 0x59, 0x3b, 0xed, 0x89,
-       0x0d, 0xcc, 0xe4, 0xde, 0x39, 0xff, 0x14, 0x5d,
-       0x69, 0x67, 0x88, 0x0c, 0x6f, 0x5f, 0x41, 0xdd,
-       0x9d, 0xe4, 0x29, 0xde, 0x3e, 0xcf, 0x25, 0xbf,
-       0x7d, 0x06, 0x25, 0x6f, 0xe1, 0x92, 0xdf, 0x7e,
-       0x2f, 0x68, 0x66, 0x92, 0xf5, 0x41, 0xfb, 0xa3,
-       0x6a, 0x3f, 0x08, 0xe8, 0xd4, 0x99, 0xdd, 0x18,
-       0x9c, 0xd9, 0x8d, 0x0f, 0x18, 0xfc, 0x1a, 0xf6,
-       0xb0, 0x62, 0x0b, 0xe8, 0x63, 0x58, 0x2b, 0xa6,
-       0xde, 0x72, 0xce, 0xcc, 0x7b, 0x1b, 0xf5, 0x77,
-       0x53, 0x10, 0x7f, 0x1b, 0xb4, 0xf2, 0x98, 0x56,
-       0xe6, 0xdd, 0x3b, 0x54, 0x1a, 0xbe, 0x3b, 0xe9,
-       0x62, 0x1d, 0xb7, 0xd1, 0xfd, 0x5d, 0x50, 0xf4,
-       0x71, 0xc5, 0xa3, 0xab, 0x86, 0xcf, 0x41, 0x4c,
-       0x55, 0xac, 0x2f, 0xb9, 0xd8, 0x0c, 0x78, 0x86,
-       0xba, 0xbb, 0xa5, 0x18, 0x73, 0xc9, 0x1b, 0x43,
-       0x9e, 0xbc, 0x84, 0xe9, 0x16, 0x8c, 0x3b, 0x78,
-       0xdb, 0xbc, 0x3d, 0x4e, 0x82, 0xdf, 0xda, 0xe9,
-       0xdb, 0x64, 0xd8, 0x46, 0x56, 0x29, 0x9d, 0x59,
-       0x02, 0xd5, 0xd2, 0x28, 0xa5, 0xfd, 0xc6, 0x1b,
-       0xc6, 0x31, 0x2b, 0x01, 0x5b, 0x8f, 0x69, 0x50,
-       0x92, 0xe1, 0xe7, 0x17, 0x45, 0x33, 0xb7, 0xb0,
-       0x9f, 0x9f, 0xd5, 0xda, 0xfc, 0xe7, 0x27, 0x78,
-       0x9b, 0xff, 0xfc, 0xa8, 0x37, 0xcc, 0xec, 0x04,
-       0xeb, 0xc7, 0xeb, 0xf5, 0xf3, 0x08, 0xb6, 0xa5,
-       0x4e, 0xab, 0x57, 0xc2, 0x56, 0xe9, 0x80, 0xd7,
-       0xc5, 0xec, 0xcc, 0x2f, 0xbd, 0x96, 0xce, 0xf3,
-       0xf1, 0x4a, 0x3d, 0x2a, 0x6d, 0x86, 0xf4, 0xc2,
-       0x6f, 0xba, 0xd7, 0x85, 0x19, 0x35, 0x8f, 0x69,
-       0x38, 0x1b, 0x6d, 0x18, 0x06, 0xaf, 0x30, 0x0d,
-       0x0b, 0x8c, 0x67, 0x2c, 0xa3, 0xa7, 0x7a, 0x4b,
-       0x90, 0xfe, 0x3e, 0xa3, 0x9b, 0xd7, 0xaf, 0x15,
-       0xb0, 0x6f, 0x25, 0x64, 0x53, 0xaf, 0x29, 0x2c,
-       0x36, 0x83, 0xa8, 0xa7, 0x54, 0x09, 0x74, 0x3e,
-       0x4b, 0x39, 0x93, 0x85, 0x73, 0x9a, 0xc1, 0x9d,
-       0x9a, 0xbf, 0x64, 0x12, 0x9f, 0x3f, 0x77, 0xff,
-       0xb7, 0xb4, 0x3e, 0x0e, 0x46, 0xe6, 0xcb, 0x8d,
-       0xa8, 0x73, 0x63, 0x2f, 0x0b, 0xf1, 0xf9, 0x0f,
-       0xfc, 0xdc, 0x68, 0xbb, 0x1d, 0xb1, 0x8f, 0xb0,
-       0x6e, 0x0f, 0x2b, 0xf0, 0x87, 0x00, 0x42, 0xac,
-       0xd1, 0x91, 0x8b, 0x5a, 0x2f, 0xe7, 0xda, 0x3b,
-       0x82, 0xf3, 0xa2, 0xdf, 0x9c, 0x40, 0x6d, 0xbe,
-       0x24, 0x81, 0x81, 0x4a, 0x2a, 0x20, 0xed, 0x30,
-       0xc9, 0xbd, 0xd6, 0x1b, 0xee, 0xca, 0x06, 0xf2,
-       0x55, 0xc6, 0xdd, 0x28, 0xc7, 0xc5, 0x64, 0x5b,
-       0x55, 0x8e, 0x1d, 0x48, 0x45, 0x0f, 0x26, 0x5e,
-       0x75, 0x16, 0x67, 0x80, 0x78, 0x89, 0xde, 0x95,
-       0x90, 0x2e, 0x20, 0x6d, 0x73, 0x61, 0x71, 0x01,
-       0x88, 0xc6, 0xc2, 0x62, 0x27, 0xa4, 0xde, 0xce,
-       0xc6, 0xf1, 0xf1, 0xac, 0xbf, 0x34, 0x60, 0x9a,
-       0x50, 0x10, 0x70, 0x9c, 0xea, 0x50, 0x32, 0x82,
-       0xba, 0x5d, 0xe4, 0x1b, 0xc6, 0x89, 0x70, 0x44,
-       0x0c, 0xda, 0x02, 0x93, 0x36, 0xea, 0x15, 0x3a,
-       0xe7, 0xf7, 0x27, 0xc8, 0x53, 0x4d, 0x6f, 0x3e,
-       0x5d, 0x6b, 0x5e, 0xe7, 0xe2, 0x6d, 0x78, 0xc4,
-       0xa5, 0x96, 0x12, 0xe7, 0x8d, 0xd7, 0xfc, 0xbf,
-       0xf6, 0x86, 0xdd, 0xe1, 0x12, 0xf1, 0xb1, 0xbc,
-       0x62, 0xc1, 0x16, 0x78, 0x18, 0x67, 0x77, 0x16,
-       0xf3, 0x3e, 0x48, 0xba, 0x1f, 0x30, 0xde, 0x4e,
-       0x3b, 0x80, 0x54, 0x5e, 0x2b, 0x7d, 0x2d, 0x35,
-       0xec, 0x96, 0x20, 0xba, 0x44, 0x04, 0xc3, 0x40,
-       0x5e, 0xf1, 0x5a, 0x9b, 0xd4, 0xcb, 0xe5, 0xbd,
-       0xd5, 0xcf, 0x79, 0xde, 0xea, 0xa3, 0x2f, 0xab,
-       0x5e, 0xa8, 0x53, 0xe0, 0xad, 0xf7, 0xf3, 0x54,
-       0x7b, 0x79, 0xeb, 0x18, 0xb7, 0x90, 0xb7, 0x8e,
-       0x48, 0xf0, 0xd9, 0x47, 0xbf, 0xae, 0x0b, 0xbb,
-       0xb5, 0xd1, 0xd3, 0xc9, 0x5a, 0x85, 0xfc, 0xb5,
-       0xa1, 0x2d, 0x6e, 0x1f, 0xe4, 0x0e, 0x35, 0x1d,
-       0xce, 0x81, 0x3f, 0x7b, 0xb9, 0x50, 0xf5, 0x3f,
-       0x6f, 0x3d, 0x89, 0xd8, 0x73, 0xbb, 0x71, 0x7d,
-       0xf6, 0xd6, 0x63, 0x62, 0x41, 0x5c, 0xca, 0x82,
-       0xb8, 0x94, 0x6d, 0x6a, 0xca, 0x7a, 0xe4, 0x0d,
-       0xa9, 0x29, 0xcd, 0xe8, 0x29, 0x2d, 0x88, 0x37,
-       0x92, 0x8f, 0x8c, 0xf3, 0x85, 0xd8, 0x4f, 0xdf,
-       0x9a, 0x86, 0xee, 0xa0, 0xdf, 0x3d, 0x70, 0x71,
-       0x0f, 0xfa, 0xd0, 0x93, 0x18, 0x7e, 0x9e, 0xf7,
-       0xd9, 0xb7, 0xd2, 0xa9, 0xc7, 0x22, 0x1c, 0xcb,
-       0x38, 0xa7, 0xc8, 0x0e, 0xcd, 0xf3, 0xb0, 0x74,
-       0xb4, 0x77, 0xe8, 0x35, 0x4c, 0xb5, 0x06, 0x53,
-       0xbd, 0x80, 0x61, 0xca, 0x75, 0xb2, 0xc2, 0x66,
-       0x34, 0x34, 0x0e, 0xea, 0x7a, 0x70, 0x66, 0xd7,
-       0xc8, 0xbc, 0x22, 0xce, 0x8f, 0xf5, 0x27, 0x78,
-       0x9f, 0xc3, 0x19, 0x1a, 0x1b, 0x29, 0xd5, 0xfd,
-       0x7c, 0x98, 0xfb, 0xe1, 0xbd, 0xc8, 0x57, 0x8c,
-       0x92, 0x13, 0xd9, 0xd8, 0x80, 0xb3, 0x41, 0xe4,
-       0x7e, 0xfe, 0x73, 0xb9, 0x9f, 0xe4, 0xf3, 0x49,
-       0x7d, 0x29, 0x93, 0x3c, 0x9e, 0x8d, 0xa1, 0x76,
-       0x4c, 0xad, 0xe7, 0xde, 0x40, 0x1f, 0xe4, 0x75,
-       0x3f, 0x2c, 0x4b, 0x39, 0xa2, 0x49, 0xca, 0x42,
-       0x4a, 0x9d, 0x36, 0x9b, 0x64, 0xbb, 0xf5, 0xd2,
-       0x98, 0xb7, 0xf0, 0x04, 0x46, 0x9d, 0xa9, 0xf8,
-       0x95, 0x9f, 0x66, 0x8e, 0xf4, 0xc5, 0x73, 0x36,
-       0x53, 0x75, 0xa5, 0xdc, 0x0d, 0x3a, 0x36, 0x47,
-       0x82, 0xc3, 0x0e, 0x36, 0x4b, 0x82, 0xc3, 0x02,
-       0xcb, 0xc5, 0xc2, 0xe6, 0x7b, 0x70, 0x38, 0xa5,
-       0x5a, 0x57, 0x3b, 0xdb, 0xc0, 0x67, 0x4d, 0xa5,
-       0x6c, 0xd6, 0x74, 0x44, 0x9d, 0x35, 0x15, 0xa6,
-       0x62, 0x5a, 0x36, 0x57, 0x82, 0x37, 0x2f, 0xb0,
-       0xd9, 0x12, 0xbc, 0x79, 0x36, 0x3e, 0xed, 0x9b,
-       0xef, 0x55, 0xeb, 0x6b, 0x67, 0xe3, 0x0c, 0x0a,
-       0xde, 0x3c, 0xe2, 0xd7, 0x19, 0x68, 0xfe, 0x74,
-       0x55, 0xdc, 0xad, 0x8d, 0x1d, 0x92, 0x47, 0x5c,
-       0x29, 0x65, 0x8b, 0xf5, 0xd2, 0x34, 0xf1, 0x41,
-       0xb1, 0x51, 0x52, 0x47, 0xff, 0x37, 0xb7, 0x8b,
-       0x30, 0xf8, 0x9a, 0x54, 0xab, 0x62, 0x9b, 0x45,
-       0xb8, 0x6c, 0x51, 0xc3, 0xb4, 0xfe, 0x91, 0x94,
-       0x54, 0x11, 0xde, 0x5c, 0xa3, 0x52, 0x56, 0x70,
-       0xaf, 0xf3, 0x66, 0x9b, 0xe6, 0x75, 0xde, 0x6c,
-       0xe4, 0x5e, 0xe7, 0xcd, 0x25, 0x1f, 0x78, 0x7b,
-       0x5d, 0xda, 0x98, 0xad, 0x72, 0x7b, 0xb9, 0x2d,
-       0xbe, 0xe9, 0x12, 0x55, 0x2f, 0xff, 0x66, 0xa1,
-       0x9a, 0x3e, 0x27, 0x96, 0x3e, 0x43, 0x4d, 0x3f,
-       0x4e, 0x9b, 0xb7, 0xa8, 0x9c, 0x56, 0x36, 0x43,
-       0x84, 0x37, 0x8d, 0x6c, 0x8e, 0x08, 0x87, 0x06,
-       0xb5, 0x14, 0x87, 0x2e, 0xf1, 0x14, 0x87, 0xce,
-       0x7b, 0xc3, 0xbf, 0xf5, 0x6a, 0xd6, 0xed, 0xc1,
-       0x15, 0xf2, 0xaf, 0xc5, 0x94, 0x31, 0x1f, 0x54,
-       0x90, 0x7e, 0x7d, 0x0e, 0x1c, 0x79, 0xf4, 0x1e,
-       0xdd, 0xce, 0x3a, 0x25, 0xb9, 0x17, 0xd7, 0xe9,
-       0x3d, 0x5d, 0x38, 0xbe, 0x9f, 0x11, 0xe1, 0xd0,
-       0x6e, 0xff, 0x6c, 0x9f, 0x4e, 0xd1, 0xfb, 0x67,
-       0x6b, 0x25, 0x0d, 0x74, 0x61, 0xba, 0x66, 0x77,
-       0x3f, 0xc0, 0xd4, 0x11, 0x41, 0xc3, 0x2b, 0x23,
-       0xe4, 0x14, 0x9f, 0x6d, 0xe1, 0x9b, 0xd1, 0xab,
-       0xa8, 0xcf, 0x26, 0xc5, 0x54, 0x37, 0xf7, 0xac,
-       0xb7, 0xaa, 0x33, 0xf3, 0xa1, 0x45, 0xae, 0xa5,
-       0xc7, 0x31, 0xf5, 0xca, 0x94, 0xdb, 0x51, 0xfe,
-       0xed, 0x98, 0x22, 0x2d, 0x30, 0x7e, 0x67, 0x80,
-       0xe6, 0x2b, 0xf3, 0x5d, 0x4b, 0xaf, 0x60, 0xcc,
-       0x83, 0x67, 0x90, 0x0f, 0x67, 0x3a, 0x70, 0xa8,
-       0xd6, 0x66, 0x67, 0xe7, 0x76, 0x5f, 0x62, 0x58,
-       0x79, 0x55, 0x67, 0x2d, 0x5b, 0x11, 0xb2, 0xd5,
-       0xf9, 0x8c, 0x3c, 0x9b, 0xbf, 0xee, 0xa8, 0x3b,
-       0x37, 0x6c, 0xd3, 0x57, 0x75, 0x6a, 0x94, 0x5a,
-       0xa4, 0x4c, 0x64, 0x94, 0x1f, 0xf1, 0xd5, 0x3f,
-       0x1c, 0x22, 0x6d, 0xe1, 0xfa, 0xbf, 0x66, 0xb6,
-       0xa6, 0x8d, 0x9f, 0x5d, 0xd3, 0xaf, 0x8a, 0xb2,
-       0x35, 0x2e, 0x6b, 0x6d, 0xb8, 0xf6, 0x1a, 0xd0,
-       0xf9, 0x04, 0x1c, 0x97, 0x10, 0xdf, 0x12, 0x17,
-       0xef, 0x90, 0x9d, 0xea, 0xd8, 0xeb, 0xf0, 0xcf,
-       0x06, 0x3a, 0x87, 0x8b, 0xd9, 0xec, 0xb5, 0x10,
-       0xef, 0x6f, 0x3f, 0xdb, 0x89, 0x3c, 0x77, 0xcb,
-       0x16, 0x16, 0x67, 0x57, 0xdb, 0x8b, 0xe6, 0x04,
-       0xe9, 0x98, 0x8a, 0xf4, 0x06, 0x3f, 0xdb, 0x58,
-       0x4b, 0x71, 0x82, 0x9a, 0xae, 0x58, 0x4d, 0xb7,
-       0x9a, 0xf1, 0x4d, 0x92, 0x03, 0x2c, 0x65, 0xb1,
-       0x9a, 0x5b, 0xba, 0x3c, 0xd6, 0x3f, 0x1b, 0x57,
-       0x83, 0xd4, 0x4e, 0xe9, 0xca, 0xf8, 0x0f, 0xba,
-       0x6d, 0x77, 0x47, 0xa3, 0xf3, 0xde, 0x8c, 0x5e,
-       0x12, 0xe1, 0x67, 0x5e, 0x8c, 0xcf, 0xa0, 0xfd,
-       0x47, 0x7d, 0x33, 0xc8, 0xef, 0xf6, 0x15, 0xa5,
-       0xb0, 0xb1, 0x91, 0xbd, 0xa5, 0xa7, 0x53, 0xc6,
-       0xe2, 0x55, 0x8f, 0x72, 0xd3, 0xbd, 0x2e, 0xc9,
-       0xee, 0x75, 0x89, 0xa9, 0xec, 0x94, 0xfd, 0x68,
-       0x3d, 0xfc, 0x8c, 0x7d, 0x57, 0x27, 0x4a, 0x21,
-       0x93, 0x08, 0xd7, 0x0e, 0x72, 0xff, 0x71, 0x70,
-       0xc0, 0xa3, 0x67, 0xe5, 0x34, 0xfa, 0x67, 0x57,
-       0xef, 0x9f, 0xa9, 0xd7, 0x64, 0x7f, 0x7c, 0x86,
-       0x64, 0x7f, 0x7c, 0xb2, 0x60, 0x02, 0xf5, 0x18,
-       0x19, 0x74, 0x1e, 0x9f, 0x5e, 0xd1, 0x97, 0x86,
-       0xd1, 0x63, 0xb3, 0x3e, 0x01, 0x87, 0xe8, 0xdb,
-       0x33, 0x9f, 0xad, 0x10, 0x26, 0xd0, 0x7a, 0xbc,
-       0x74, 0x2d, 0xab, 0x4d, 0x1a, 0xd6, 0xc0, 0x41,
-       0x35, 0xd8, 0xa9, 0xe6, 0x74, 0xf0, 0x19, 0xcc,
-       0x69, 0x09, 0xcd, 0x21, 0xb1, 0x9f, 0xc1, 0xc1,
-       0x27, 0x31, 0xde, 0xa9, 0xc5, 0x53, 0x99, 0x0e,
-       0x76, 0xd1, 0x09, 0x42, 0x64, 0xbd, 0x4a, 0x32,
-       0x69, 0x97, 0x71, 0x35, 0xe3, 0xec, 0x6a, 0x94,
-       0xba, 0xe2, 0x81, 0x83, 0x8b, 0x79, 0x6f, 0x3e,
-       0xe8, 0xf7, 0xae, 0xed, 0x5b, 0x14, 0x76, 0xf3,
-       0xf1, 0xeb, 0x60, 0x29, 0xbb, 0x87, 0x90, 0xcc,
-       0xef, 0x1d, 0x20, 0x5e, 0xa0, 0xae, 0x94, 0xb3,
-       0xe4, 0x74, 0xff, 0xec, 0xe0, 0x3b, 0x47, 0x6f,
-       0x57, 0xc6, 0x86, 0xbb, 0xf4, 0x50, 0xa3, 0x53,
-       0x52, 0x2c, 0x2e, 0x13, 0xcc, 0xd7, 0x29, 0x16,
-       0x8b, 0x4b, 0x0f, 0x8b, 0xb0, 0x1d, 0x0e, 0x9a,
-       0xb9, 0xe6, 0x0f, 0xe2, 0x7c, 0xea, 0xb3, 0x08,
-       0xef, 0x07, 0x3f, 0xbd, 0xcc, 0xc7, 0xa1, 0x9f,
-       0x5e, 0x60, 0x71, 0x99, 0x58, 0xce, 0x69, 0x54,
-       0xce, 0xe1, 0x77, 0x1e, 0xb0, 0xbe, 0x1b, 0xd3,
-       0xc1, 0xbb, 0x6f, 0x67, 0x18, 0x39, 0xf7, 0x57,
-       0x75, 0x22, 0xd7, 0x7d, 0x37, 0x72, 0xa5, 0x80,
-       0x77, 0xad, 0x77, 0x5f, 0xcf, 0x5a, 0xd9, 0xc2,
-       0xeb, 0xad, 0x40, 0x74, 0x9c, 0xba, 0x76, 0xc2,
-       0x5c, 0x7f, 0xba, 0x01, 0x4b, 0x99, 0xa3, 0xa4,
-       0x62, 0x5a, 0xe6, 0x25, 0xb1, 0x95, 0xe0, 0xb3,
-       0x69, 0xd8, 0x4e, 0xf0, 0x59, 0x01, 0x1b, 0x0d,
-       0x1f, 0x46, 0x1e, 0x19, 0x63, 0x8b, 0x98, 0xd7,
-       0x53, 0xf5, 0xf8, 0xd3, 0x5a, 0x8c, 0x4f, 0xfd,
-       0x13, 0xa7, 0x83, 0x6c, 0xbb, 0x7c, 0x90, 0xac,
-       0x7f, 0xc6, 0xae, 0xc0, 0x28, 0xfe, 0xc5, 0x05,
-       0xf6, 0x16, 0xf8, 0x35, 0xba, 0xce, 0x4c, 0x66,
-       0xd7, 0x14, 0x76, 0xd5, 0xb3, 0xab, 0x89, 0x5d,
-       0x2d, 0xfc, 0x4d, 0x71, 0xfe, 0xfe, 0xe9, 0x8c,
-       0xcb, 0xe9, 0x11, 0xac, 0xd5, 0x76, 0x6b, 0x3f,
-       0x6c, 0x1f, 0x59, 0x87, 0xf9, 0xef, 0xc1, 0x30,
-       0xda, 0x6b, 0x32, 0xb6, 0x69, 0xf2, 0x46, 0xd8,
-       0x3e, 0x4a, 0xc4, 0xdf, 0x21, 0x31, 0xf6, 0x6c,
-       0xcd, 0x79, 0xd7, 0x83, 0x4b, 0xc0, 0xf9, 0xf5,
-       0x87, 0x9b, 0x82, 0xa1, 0xd5, 0x9d, 0x2d, 0xed,
-       0x81, 0xbe, 0x49, 0x80, 0x71, 0x52, 0x47, 0xa3,
-       0xac, 0x34, 0x2f, 0x5d, 0xd6, 0x7a, 0xee, 0x74,
-       0x06, 0x20, 0x63, 0xf1, 0xaa, 0x95, 0x0d, 0x2b,
-       0xea, 0xdb, 0x96, 0x67, 0xe7, 0x4c, 0x81, 0x1c,
-       0x4c, 0x25, 0xc4, 0xca, 0x3c, 0xe5, 0xba, 0x3a,
-       0xdc, 0xff, 0xc0, 0xd4, 0xac, 0xbb, 0x63, 0x98,
-       0x78, 0x77, 0x7a, 0xd6, 0xc7, 0x77, 0x66, 0x4e,
-       0x75, 0x4c, 0x9e, 0x3e, 0xf3, 0xc1, 0x2e, 0x70,
-       0xce, 0x5b, 0x58, 0xe6, 0xaf, 0x5d, 0x3c, 0xbf,
-       0x62, 0x6e, 0xf5, 0xe0, 0x44, 0xca, 0xc7, 0x5d,
-       0x53, 0x5a, 0x3e, 0xcb, 0xeb, 0x9b, 0x5d, 0x79,
-       0xe5, 0xec, 0x3f, 0x50, 0x3e, 0x33, 0x16, 0xd5,
-       0x95, 0x2c, 0xf0, 0x54, 0xcd, 0xb9, 0x6f, 0xda,
-       0x43, 0x7f, 0x22, 0x9f, 0x6f, 0xfc, 0xd5, 0x75,
-       0xf9, 0x4c, 0xfa, 0x2f, 0xc9, 0x67, 0x48, 0x6f,
-       0x53, 0xa6, 0x6b, 0x7a, 0x5b, 0x45, 0x7a, 0xbb,
-       0xff, 0x81, 0x61, 0x7a, 0xbb, 0xef, 0x2e, 0xae,
-       0xb7, 0xd5, 0x9a, 0xde, 0xa6, 0xfe, 0x79, 0x7a,
-       0x9b, 0x38, 0x71, 0x52, 0xc6, 0x9d, 0x0f, 0x66,
-       0x66, 0x39, 0x26, 0x3f, 0x74, 0xb7, 0x56, 0x9f,
-       0x45, 0x54, 0x9f, 0x6f, 0xfc, 0xd5, 0xb0, 0xfa,
-       0x4c, 0x4b, 0xe7, 0xf5, 0x59, 0xcc, 0xeb, 0x53,
-       0x3c, 0x63, 0xe6, 0x9f, 0x57, 0x9f, 0xff, 0xaa,
-       0x7c, 0x86, 0xf4, 0x76, 0x6a, 0xd7, 0x30, 0x7b,
-       0x1b, 0xbc, 0x7b, 0x98, 0xde, 0xae, 0x9c, 0x9d,
-       0xf4, 0x97, 0xd8, 0xdb, 0x9a, 0x89, 0xe9, 0xff,
-       0x98, 0xa1, 0xda, 0x81, 0x38, 0xcc, 0x0e, 0x4e,
-       0x66, 0x0d, 0xab, 0xcf, 0x7b, 0x07, 0x1e, 0xfc,
-       0x8b, 0xec, 0xe0, 0x55, 0xd7, 0x0f, 0x7a, 0xf6,
-       0xfe, 0xf3, 0xeb, 0x3f, 0xfa, 0xfe, 0x8f, 0x99,
-       0x1d, 0x7c, 0xd8, 0xf3, 0xbd, 0x97, 0xaf, 0x3d,
-       0xff, 0xc3, 0x6d, 0x57, 0x77, 0x73, 0x3b, 0xf8,
-       0xe8, 0x14, 0xdf, 0x95, 0xf1, 0x0f, 0xf7, 0xdd,
-       0xc5, 0xeb, 0xf3, 0xca, 0xbf, 0x7e, 0xfc, 0xe2,
-       0x6b, 0xff, 0x7b, 0xcf, 0x9f, 0x6d, 0x07, 0x99,
-       0xe7, 0xd2, 0xef, 0x72, 0xfc, 0x63, 0xdf, 0xc4,
-       0x8f, 0x4f, 0x4f, 0x9e, 0x82, 0xf9, 0x48, 0xab,
-       0x35, 0x7b, 0x7b, 0x30, 0x83, 0xf2, 0xf9, 0xba,
-       0xa6, 0xb7, 0xe5, 0x9d, 0x9d, 0x2c, 0x9f, 0x87,
-       0x99, 0xde, 0xb2, 0xef, 0x9b, 0x36, 0xfd, 0xcf,
-       0xcb, 0x67, 0xa8, 0x7d, 0x7a, 0x1e, 0x42, 0xbd,
-       0xb9, 0x17, 0x6b, 0x76, 0x00, 0x4c, 0x6f, 0xf3,
-       0x34, 0xbd, 0xcd, 0xb9, 0x93, 0xdb, 0xc1, 0x42,
-       0xa6, 0xb7, 0x99, 0x39, 0x53, 0xef, 0xfe, 0x73,
-       0xed, 0x60, 0xd2, 0x7f, 0x45, 0x3e, 0x6e, 0x4f,
-       0x49, 0x69, 0x19, 0x4a, 0xaa, 0x20, 0x51, 0x55,
-       0x73, 0xab, 0xe7, 0xf9, 0x6b, 0x6a, 0xe7, 0x2f,
-       0x58, 0x58, 0xb7, 0x68, 0x31, 0xdf, 0x4b, 0xa0,
-       0x34, 0xb7, 0x90, 0xd2, 0xda, 0xda, 0x03, 0x5f,
-       0x0f, 0x76, 0x84, 0x3a, 0x57, 0x3c, 0xbc, 0x72,
-       0xd5, 0x6a, 0x61, 0x68, 0xc3, 0x41, 0x9c, 0xd7,
-       0xba, 0x6b, 0x62, 0xc6, 0xa4, 0x29, 0xa8, 0xcf,
-       0xfb, 0x1f, 0x28, 0x9e, 0xe1, 0xca, 0x39, 0x77,
-       0xba, 0xef, 0xca, 0xd9, 0xc1, 0x25, 0x5d, 0xff,
-       0xd8, 0xf3, 0xd0, 0xab, 0x3b, 0xbf, 0xf1, 0x57,
-       0xc2, 0xce, 0x3f, 0xf1, 0x27, 0x4c, 0x4c, 0xff,
-       0x07, 0xb4, 0xc7, 0xbb, 0x1c, 0x93, 0xb3, 0xee,
-       0xce, 0x9e, 0x92, 0x33, 0x75, 0x28, 0x8b, 0x69,
-       0xf7, 0x15, 0x4f, 0x9f, 0x31, 0xd3, 0xf5, 0xf9,
-       0x05, 0xbd, 0x7f, 0xc9, 0x03, 0x0f, 0x3e, 0xb4,
-       0xf3, 0xf3, 0x8b, 0xfb, 0x8d, 0xae, 0xbf, 0xda,
-       0xf9, 0xf1, 0xe0, 0xb9, 0x9d, 0x67, 0x4f, 0xef,
-       0xfc, 0x78, 0xe7, 0xce, 0xbe, 0x9d, 0xff, 0x8f,
-       0xff, 0x0d, 0x69, 0x96, 0xab, 0xf4, 0x2f, 0xfd,
-       0xe6, 0xc5, 0x7f, 0xff, 0x3f, 0x76, 0xce, 0x53,
-       0xec, 0xc4, 0x0d, 0x4f, 0xb0, 0x49, 0x5a, 0x26,
-       0x54, 0xb7, 0xb7, 0xb4, 0x85, 0x04, 0x0c, 0x36,
-       0x34, 0x37, 0x35, 0x0a, 0x52, 0x28, 0x76, 0x72,
-       0x69, 0x06, 0xf8, 0x6a, 0xfc, 0xc2, 0x9f, 0x64,
-       0x8a, 0x67, 0xe8, 0x68, 0x0a, 0x7d, 0xb1, 0x84,
-       0x1b, 0x18, 0x86, 0x8b, 0xa7, 0xbd, 0x47, 0x5f,
-       0x20, 0x1e, 0x23, 0x6e, 0x14, 0xc9, 0x88, 0xee,
-       0xd6, 0xd6, 0x78, 0x62, 0x87, 0xd0, 0xd0, 0xda,
-       0x24, 0x05, 0xe9, 0x1c, 0x93, 0xe5, 0x28, 0x34,
-       0xb8, 0x2a, 0xee, 0x38, 0x56, 0x55, 0x64, 0x4e,
-       0x4e, 0x8e, 0x05, 0xdc, 0xfc, 0x44, 0x93, 0xc6,
-       0x20, 0x5d, 0x5b, 0x3a, 0x84, 0xb6, 0xf6, 0x87,
-       0xe9, 0xe4, 0xd5, 0xaa, 0x76, 0xa1, 0xb1, 0xa5,
-       0x63, 0x99, 0xd0, 0xd2, 0xa6, 0x46, 0x31, 0xe6,
-       0xda, 0xa0, 0xd4, 0xb0, 0x4c, 0x68, 0x68, 0x0f,
-       0x06, 0x3b, 0x03, 0x21, 0x2c, 0x26, 0x23, 0x7a,
-       0xa4, 0x46, 0xc1, 0xd3, 0xda, 0xde, 0xb0, 0xec,
-       0xa1, 0x92, 0xe6, 0xa6, 0x86, 0x65, 0x1d, 0x9d,
-       0xcb, 0x39, 0xbd, 0x8a, 0xce, 0x4b, 0x11, 0x4a,
-       0xe7, 0xd6, 0x70, 0x49, 0x8c, 0x56, 0xca, 0x64,
-       0x76, 0xb0, 0x83, 0xb6, 0x9a, 0xa6, 0x04, 0x82,
-       0xed, 0xa1, 0xa6, 0x86, 0x98, 0xa0, 0x8a, 0x36,
-       0xda, 0x61, 0x8e, 0xc2, 0x5a, 0x42, 0xcb, 0xa5,
-       0x80, 0x96, 0x20, 0x88, 0x1c, 0x54, 0x7c, 0x3a,
-       0x56, 0xa5, 0x69, 0x79, 0x20, 0xb4, 0x4a, 0x65,
-       0x2e, 0x2d, 0xe3, 0x72, 0xd9, 0x29, 0x2d, 0x71,
-       0x39, 0xb6, 0x09, 0xe5, 0xe5, 0x35, 0x74, 0x42,
-       0x4b, 0x45, 0x5b, 0x28, 0x87, 0x85, 0x63, 0xd9,
-       0x3b, 0xe6, 0x22, 0x46, 0x87, 0x80, 0x95, 0x96,
-       0x4c, 0xa1, 0x08, 0x12, 0xd9, 0xd1, 0x19, 0x08,
-       0xb4, 0x07, 0xb1, 0x0c, 0x93, 0x51, 0x26, 0x7b,
-       0x47, 0xa0, 0x55, 0x08, 0x48, 0xa1, 0x66, 0x35,
-       0xfb, 0xa6, 0x15, 0x2d, 0x0d, 0xf1, 0x47, 0xba,
-       0x30, 0x2a, 0xb3, 0x21, 0xa9, 0x15, 0x75, 0xd8,
-       0xb8, 0x4a, 0x68, 0x5a, 0xd9, 0xd2, 0x81, 0xda,
-       0x1e, 0xaa, 0x9e, 0xdc, 0x89, 0x2d, 0x31, 0xc4,
-       0x77, 0x5d, 0xda, 0x12, 0xa9, 0xed, 0xae, 0x90,
-       0xd0, 0x80, 0x69, 0x43, 0x4d, 0x02, 0x3b, 0x0f,
-       0x86, 0x91, 0xe7, 0xb7, 0x2d, 0x43, 0xcd, 0xb7,
-       0x69, 0xc7, 0x94, 0xf1, 0x2a, 0xaa, 0xc5, 0xe9,
-       0x58, 0xd5, 0x16, 0x92, 0x56, 0x0e, 0x23, 0xa9,
-       0x6d, 0x39, 0x8c, 0x16, 0x6c, 0x52, 0xb0, 0x24,
-       0x4d, 0xc1, 0x61, 0x44, 0xd4, 0x68, 0x67, 0xd3,
-       0x30, 0x4a, 0x9b, 0xb4, 0x7c, 0x38, 0xa1, 0x23,
-       0x14, 0x6c, 0x69, 0x53, 0x86, 0x91, 0x9a, 0x56,
-       0xd2, 0xc6, 0x52, 0x3a, 0xd3, 0xe6, 0x26, 0xf5,
-       0xe0, 0x96, 0xd0, 0xde, 0x2e, 0x60, 0x41, 0x57,
-       0x09, 0xf5, 0xcc, 0xe4, 0x02, 0xcc, 0xe4, 0x58,
-       0x4c, 0xbb, 0x2c, 0xb7, 0xb7, 0x09, 0x0b, 0x83,
-       0xed, 0x6d, 0x4a, 0xac, 0x48, 0x42, 0x5b, 0xe7,
-       0xf2, 0x7a, 0xb5, 0x64, 0x53, 0xfe, 0xd4, 0x9f,
-       0xe0, 0x2d, 0xab, 0xac, 0x16, 0xaa, 0xdd, 0xb3,
-       0xca, 0x84, 0x3f, 0xc9, 0x3b, 0xc5, 0xe2, 0xa7,
-       0xb3, 0x6b, 0x30, 0x1f, 0xa1, 0xad, 0xe9, 0xe1,
-       0x29, 0x58, 0x5b, 0x81, 0x0e, 0x0e, 0xee, 0x68,
-       0x46, 0x2b, 0x46, 0x13, 0x58, 0xde, 0xde, 0xd8,
-       0x22, 0xaf, 0x8a, 0x15, 0xa3, 0xc3, 0xe2, 0x26,
-       0x6e, 0xad, 0x23, 0xb4, 0xb4, 0x61, 0xd5, 0x91,
-       0x5b, 0xea, 0xe8, 0x68, 0x5a, 0x5e, 0x8f, 0x55,
-       0x2c, 0x2c, 0x72, 0xae, 0x74, 0x62, 0x13, 0x34,
-       0x36, 0x59, 0x4a, 0xe3, 0x19, 0xf9, 0xdf, 0x34,
-       0x32, 0xa4, 0x18, 0xef, 0xd4, 0x9b, 0x26, 0xf3,
-       0xde, 0x2c, 0x59, 0x73, 0xd3, 0x4a, 0xa1, 0xb1,
-       0x73, 0x79, 0x40, 0x68, 0x97, 0x05, 0xb5, 0x2f,
-       0x0e, 0x95, 0x8d, 0x13, 0x2c, 0x73, 0xfe, 0xa3,
-       0x09, 0xab, 0x6e, 0x96, 0x50, 0xea, 0x68, 0xa8,
-       0xa8, 0xb8, 0x2e, 0xa9, 0xa5, 0x8c, 0xe2, 0xb0,
-       0x75, 0xc8, 0x01, 0xc5, 0x38, 0x99, 0xa6, 0xa6,
-       0x0a, 0x4d, 0x8d, 0x2d, 0x68, 0x94, 0x9d, 0x1d,
-       0xa1, 0xf6, 0xe5, 0x71, 0xda, 0xaa, 0x5d, 0x54,
-       0x5d, 0xc6, 0x64, 0xe7, 0x08, 0x43, 0x29, 0x42,
-       0xab, 0x02, 0x4d, 0x9a, 0xc8, 0x12, 0x22, 0x75,
-       0x04, 0x1b, 0x84, 0x26, 0x34, 0xef, 0xc6, 0xa6,
-       0x8e, 0x10, 0x31, 0x34, 0xb4, 0x07, 0xd0, 0xd9,
-       0x68, 0x05, 0xae, 0x27, 0xcf, 0x60, 0x99, 0xc7,
-       0x18, 0x43, 0xc1, 0xd0, 0x10, 0x27, 0x31, 0x2e,
-       0x0f, 0xa0, 0x87, 0x12, 0x42, 0x0f, 0xb7, 0x0f,
-       0xe3, 0xee, 0xb0, 0xcc, 0x1d, 0xc6, 0xce, 0x5a,
-       0x75, 0x1a, 0x75, 0x96, 0xd6, 0x58, 0xc6, 0x65,
-       0x37, 0xc9, 0xb8, 0x69, 0x65, 0x43, 0xb3, 0xd4,
-       0xa6, 0xdc, 0x4c, 0x60, 0xf9, 0xcd, 0x05, 0xb6,
-       0x35, 0x5a, 0xd0, 0x0d, 0xc4, 0xc5, 0x90, 0x41,
-       0xa8, 0x31, 0x6a, 0xbf, 0x10, 0x1c, 0x64, 0xf8,
-       0x0d, 0x52, 0x47, 0x53, 0x47, 0x53, 0x5b, 0x47,
-       0x0b, 0x39, 0xcb, 0xc9, 0x96, 0xf2, 0x8a, 0xcf,
-       0x4b, 0xc4, 0x6c, 0xaa, 0x93, 0x9d, 0x23, 0x65,
-       0x29, 0x99, 0x5b, 0x1d, 0xc7, 0xa5, 0xaa, 0x8f,
-       0x71, 0xa1, 0x8a, 0x02, 0x4d, 0xc1, 0x29, 0xad,
-       0xa8, 0x67, 0x4b, 0x35, 0xd1, 0x03, 0x2d, 0x0d,
-       0x6d, 0xed, 0x71, 0x4a, 0x56, 0xe4, 0x95, 0x53,
-       0x82, 0x2d, 0xc4, 0x24, 0x38, 0x58, 0xdc, 0x74,
-       0x67, 0x76, 0x6e, 0x76, 0x5e, 0x76, 0x4e, 0xce,
-       0x64, 0xc1, 0x21, 0xc7, 0x8e, 0x35, 0xc4, 0x1c,
-       0x26, 0x5b, 0x2c, 0x9e, 0x1b, 0x2c, 0x80, 0x1a,
-       0xb6, 0x29, 0x34, 0x95, 0x8f, 0x26, 0xe4, 0x12,
-       0x5b, 0xd4, 0x8e, 0xcd, 0x7a, 0x2b, 0xeb, 0xac,
-       0x16, 0x8f, 0xef, 0x4f, 0xa4, 0x12, 0x68, 0x98,
-       0x89, 0x4f, 0x50, 0x2a, 0x5c, 0xff, 0x87, 0x5d,
-       0xa2, 0xa9, 0xb5, 0x29, 0x44, 0xce, 0x30, 0x5e,
-       0x76, 0x87, 0x65, 0xce, 0xc2, 0x1c, 0x47, 0x7d,
-       0xd7, 0xc3, 0x5d, 0xad, 0x93, 0xe3, 0x86, 0x9d,
-       0x38, 0xe1, 0x6a, 0xeb, 0x3c, 0x2c, 0x85, 0x1a,
-       0x9a, 0x91, 0xf9, 0x26, 0x82, 0x57, 0xb4, 0x34,
-       0x3d, 0xcc, 0xc4, 0x5e, 0xc7, 0x5a, 0xfa, 0x85,
-       0x65, 0x18, 0xc6, 0x3c, 0xeb, 0x66, 0x7a, 0xa1,
-       0x4d, 0xf1, 0x12, 0x36, 0x09, 0x8e, 0x3d, 0x4a,
-       0x50, 0x5a, 0x1e, 0x37, 0xd2, 0x5a, 0x6a, 0x91,
-       0xa1, 0xad, 0x1e, 0x4d, 0x3f, 0x10, 0xc7, 0x1f,
-       0xc2, 0x21, 0xaf, 0x29, 0xbe, 0x59, 0x1d, 0x1d,
-       0x93, 0x2d, 0xb5, 0xee, 0x9b, 0x48, 0xe6, 0x9c,
-       0x21, 0xb2, 0xd2, 0xbb, 0xd4, 0xc8, 0xbb, 0x68,
-       0xac, 0x53, 0xa7, 0x0c, 0x96, 0xd2, 0x32, 0xcf,
-       0xfc, 0x59, 0xd7, 0x97, 0x3d, 0x40, 0x25, 0x25,
-       0xcb, 0x6d, 0x0a, 0xb0, 0xb3, 0xc7, 0x56, 0xb0,
-       0xd1, 0xae, 0xc3, 0x62, 0x29, 0xf5, 0x57, 0x2c,
-       0x28, 0x13, 0xe2, 0x8c, 0x82, 0x37, 0x4f, 0x2b,
-       0xc6, 0xab, 0x23, 0xb2, 0xc3, 0x39, 0x35, 0x77,
-       0x32, 0xba, 0xe4, 0x20, 0xfd, 0x96, 0x53, 0x3d,
-       0xd0, 0xb2, 0x68, 0x4c, 0x9a, 0xca, 0x46, 0x57,
-       0x64, 0x26, 0x51, 0x96, 0x39, 0x73, 0x6b, 0xe7,
-       0xfa, 0xaf, 0xcf, 0x36, 0xd4, 0x19, 0xd4, 0x06,
-       0xf6, 0xe5, 0xed, 0x21, 0x3a, 0xce, 0xac, 0xcd,
-       0x42, 0xa7, 0x62, 0xba, 0x6b, 0xd9, 0xf8, 0x30,
-       0xc4, 0xa8, 0x89, 0x16, 0xe4, 0x56, 0xb4, 0xd9,
-       0x55, 0x6c, 0x2c, 0x55, 0x39, 0xe7, 0xc5, 0xb3,
-       0x4e, 0x13, 0xbe, 0xde, 0xd9, 0x82, 0x73, 0x83,
-       0x9b, 0xf2, 0x97, 0x56, 0xd4, 0xcc, 0x2e, 0xf1,
-       0xce, 0x1e, 0x5e, 0x84, 0x06, 0x9a, 0x2c, 0xdc,
-       0xc0, 0xe8, 0xe7, 0x83, 0xef, 0xb0, 0xe6, 0xd5,
-       0xa6, 0x00, 0x96, 0x12, 0x6c, 0xfc, 0x1b, 0xa2,
-       0xd5, 0x3e, 0xdf, 0xd0, 0x19, 0x0c, 0x36, 0xe1,
-       0x5c, 0x28, 0xc6, 0x2d, 0x08, 0x8e, 0xbb, 0xa6,
-       0xde, 0xc5, 0xf4, 0x43, 0x5e, 0xa6, 0x2d, 0x34,
-       0xd9, 0x52, 0x49, 0x0d, 0x4c, 0x65, 0xa6, 0xe6,
-       0xd1, 0xd2, 0xb3, 0x13, 0xdc, 0x24, 0x3e, 0x14,
-       0xe3, 0x6c, 0x47, 0x75, 0x30, 0x35, 0x1a, 0xeb,
-       0x50, 0xff, 0x45, 0xf5, 0x4b, 0x43, 0xa6, 0x1b,
-       0x6a, 0x57, 0x13, 0x59, 0x6a, 0xaa, 0x85, 0x61,
-       0x4a, 0x13, 0x62, 0xac, 0xa1, 0xe6, 0x26, 0x3a,
-       0x31, 0xae, 0x93, 0xa6, 0x14, 0xea, 0xd9, 0xf6,
-       0x72, 0x10, 0x3d, 0x2c, 0xd1, 0x87, 0x7a, 0xb8,
-       0x65, 0x8e, 0x7b, 0x76, 0x19, 0xd5, 0x7c, 0x98,
-       0x3a, 0xd5, 0x19, 0x82, 0x44, 0xe3, 0x5a, 0x9c,
-       0x0a, 0x4a, 0xcb, 0x2a, 0x6f, 0xcc, 0x4c, 0xeb,
-       0x00, 0xbc, 0x12, 0x58, 0x61, 0xec, 0xf1, 0x7c,
-       0xaa, 0x14, 0xa7, 0xbb, 0xb9, 0xd5, 0x8b, 0x98,
-       0xc7, 0xe4, 0xde, 0x52, 0xcd, 0x84, 0xbb, 0x6a,
-       0x56, 0x0d, 0x7f, 0x0d, 0xb7, 0x69, 0x5e, 0xe3,
-       0xb6, 0x7a, 0xb5, 0xb7, 0xa0, 0x72, 0xb8, 0x21,
-       0xf1, 0xa2, 0xc7, 0xb7, 0xd6, 0xc2, 0x9b, 0xa5,
-       0x88, 0xb7, 0x3d, 0x52, 0xd2, 0xb0, 0xe6, 0xcd,
-       0x2b, 0xbf, 0xb1, 0xf0, 0x2c, 0x8b, 0x61, 0x66,
-       0xc0, 0x0c, 0x99, 0x29, 0x10, 0x07, 0x25, 0xa9,
-       0x43, 0x2b, 0x60, 0x79, 0x5e, 0xe9, 0xe7, 0xa7,
-       0x66, 0x33, 0x32, 0x4c, 0xc6, 0xb3, 0x8f, 0xa5,
-       0x8b, 0xcb, 0xdc, 0xe3, 0x11, 0xe2, 0xda, 0x5d,
-       0x53, 0x80, 0xd4, 0xda, 0xd0, 0xd9, 0x4a, 0x8a,
-       0xae, 0x6f, 0x6f, 0x0f, 0x4d, 0x61, 0xa3, 0x05,
-       0xb7, 0x4c, 0x9c, 0xc6, 0x5a, 0x68, 0x8e, 0x79,
-       0x83, 0xb7, 0x51, 0x70, 0xf8, 0x6c, 0x69, 0xe3,
-       0x76, 0xce, 0x4e, 0x0b, 0x24, 0xb5, 0xb0, 0xd9,
-       0x28, 0x75, 0xa7, 0x0e, 0x4b, 0xb5, 0xdb, 0x5f,
-       0x7b, 0x43, 0x22, 0xf2, 0xf4, 0xcc, 0x41, 0xa1,
-       0x29, 0x86, 0x5a, 0x28, 0x5d, 0x87, 0xa5, 0xd2,
-       0x7d, 0x7d, 0x75, 0x62, 0xd6, 0xd8, 0xda, 0x6a,
-       0xa9, 0xb9, 0x59, 0x2c, 0x53, 0x0a, 0x8f, 0x2d,
-       0xf9, 0x1c, 0x9b, 0xa3, 0x4c, 0x1a, 0x82, 0x9d,
-       0x6d, 0xcc, 0xe5, 0x94, 0x54, 0x96, 0xb9, 0x6f,
-       0xe8, 0xfb, 0x6c, 0x5d, 0x10, 0xef, 0x2d, 0xb9,
-       0xdf, 0x20, 0x05, 0x08, 0x0e, 0xf5, 0xd8, 0xdb,
-       0xd6, 0xf6, 0x0e, 0xec, 0x2f, 0xfe, 0x32, 0xcf,
-       0xdc, 0xb9, 0xb5, 0xd7, 0x25, 0x57, 0x39, 0x29,
-       0xd1, 0xb2, 0xa6, 0xa6, 0x80, 0x76, 0x50, 0x2e,
-       0xba, 0xbb, 0x96, 0x46, 0xec, 0x65, 0x16, 0x4b,
-       0x6d, 0xcd, 0x50, 0xa7, 0x69, 0x25, 0x95, 0xa8,
-       0xce, 0xb1, 0xa5, 0xad, 0x89, 0x4c, 0x05, 0x15,
-       0x80, 0x2c, 0xa5, 0xd7, 0xf3, 0x90, 0x15, 0xa3,
-       0xb4, 0xeb, 0xf8, 0x70, 0xdc, 0x56, 0x45, 0x0c,
-       0xf3, 0xb3, 0x8c, 0x85, 0x8d, 0xa4, 0x38, 0x3a,
-       0x63, 0x43, 0xb4, 0xb2, 0xe2, 0x90, 0x00, 0x1c,
-       0x0e, 0xcb, 0xea, 0x4a, 0xca, 0xaa, 0xaf, 0xaf,
-       0x34, 0x9b, 0xe7, 0xdc, 0xe8, 0x66, 0xe7, 0xce,
-       0xaf, 0xad, 0x9e, 0x5f, 0x3b, 0xcc, 0x2e, 0xd4,
-       0x5e, 0xd1, 0xde, 0x19, 0x0a, 0x74, 0x86, 0xc8,
-       0x82, 0x55, 0x8f, 0xe0, 0x2e, 0x57, 0xed, 0x87,
-       0x4f, 0x1b, 0xb5, 0x89, 0x96, 0x36, 0x07, 0xfc,
-       0x5a, 0x51, 0x6e, 0xa1, 0xa5, 0xb4, 0xfc, 0x26,
-       0xe3, 0x42, 0xfc, 0xac, 0x91, 0xb3, 0x95, 0x57,
-       0x94, 0x5f, 0x37, 0x7b, 0x18, 0x36, 0x7d, 0xc8,
-       0x51, 0xd9, 0xaa, 0xdd, 0x95, 0x37, 0x9a, 0x1f,
-       0xcd, 0xde, 0x28, 0x02, 0xa5, 0x06, 0x5a, 0x25,
-       0x9c, 0xff, 0xd5, 0xd6, 0x94, 0xdc, 0x94, 0x89,
-       0x45, 0x68, 0x5c, 0xf9, 0xb9, 0xb3, 0x6f, 0x2e,
-       0x0a, 0x23, 0x9a, 0x57, 0x6b, 0x6c, 0x82, 0xa3,
-       0x3a, 0xd8, 0xde, 0x48, 0xc3, 0xdc, 0x8a, 0x96,
-       0xd0, 0xaa, 0x6c, 0xa1, 0xac, 0x33, 0xd8, 0x7e,
-       0x0f, 0x4d, 0x3a, 0x72, 0xd0, 0x77, 0x96, 0xdd,
-       0x64, 0xe4, 0xed, 0x78, 0xb8, 0x85, 0x86, 0xaf,
-       0x40, 0xfb, 0xc3, 0x4d, 0x74, 0xd2, 0x65, 0xa3,
-       0xa5, 0xa6, 0xac, 0x76, 0x8e, 0xbb, 0x1a, 0x57,
-       0x06, 0x81, 0x98, 0x75, 0x4e, 0x13, 0x6a, 0x70,
-       0xdc, 0x67, 0xfa, 0x5f, 0xd6, 0xb4, 0x8a, 0x16,
-       0x76, 0x8e, 0xf9, 0x35, 0xee, 0xec, 0x12, 0x6f,
-       0x76, 0x69, 0x76, 0xf9, 0x64, 0xcb, 0x4c, 0x64,
-       0x19, 0x5a, 0x6e, 0xa8, 0x29, 0x9a, 0x68, 0xd9,
-       0xc2, 0xdc, 0x5f, 0x5b, 0x5c, 0xa4, 0x65, 0x41,
-       0x99, 0xff, 0x26, 0x65, 0x20, 0xc9, 0xda, 0x69,
-       0xcd, 0xea, 0x41, 0x9c, 0x75, 0xc2, 0x4d, 0x66,
-       0x14, 0xb8, 0x50, 0x0b, 0x59, 0x66, 0x57, 0x54,
-       0x56, 0xde, 0x10, 0xa3, 0x4e, 0x4a, 0xb8, 0x10,
-       0x8b, 0xb7, 0xac, 0xae, 0x72, 0x6e, 0xc9, 0x6c,
-       0xc1, 0xd1, 0xde, 0xd6, 0x85, 0xd3, 0xe5, 0xc9,
-       0x71, 0x35, 0x45, 0x43, 0xc4, 0x39, 0xb9, 0xd4,
-       0xd8, 0xd4, 0xd0, 0x42, 0x46, 0x87, 0x33, 0xf1,
-       0x26, 0x72, 0x34, 0x8d, 0x4d, 0xb2, 0xd4, 0xd9,
-       0x8a, 0xa6, 0x5f, 0x9e, 0xab, 0x4a, 0x2c, 0x61,
-       0x7d, 0x8c, 0x1f, 0xa2, 0x8b, 0x8e, 0x4b, 0xa5,
-       0xd6, 0xb6, 0x2b, 0x0a, 0x1b, 0x65, 0x3a, 0x9a,
-       0xb0, 0xf1, 0x59, 0xea, 0xf6, 0xb6, 0xa9, 0x98,
-       0x07, 0x26, 0x74, 0xaa, 0xba, 0x52, 0x35, 0x2a,
-       0x29, 0x98, 0x57, 0xee, 0xd4, 0x3c, 0x4b, 0xf9,
-       0x3d, 0x6a, 0xe2, 0xb2, 0x36, 0x9c, 0x93, 0x4f,
-       0x2d, 0xc3, 0x4a, 0xf0, 0x99, 0x46, 0xd0, 0x52,
-       0x5e, 0x38, 0x5c, 0x2e, 0xb3, 0x9a, 0xa9, 0x78,
-       0x75, 0xe6, 0x09, 0x25, 0xd5, 0xf3, 0x59, 0x06,
-       0x96, 0xb2, 0x8e, 0x06, 0xce, 0xc4, 0x96, 0xfc,
-       0x53, 0x5b, 0x14, 0xec, 0x30, 0x4d, 0x02, 0xbd,
-       0xc5, 0x64, 0xa9, 0x95, 0xea, 0x79, 0x94, 0x5a,
-       0xa0, 0xfa, 0x56, 0xa9, 0x8d, 0xbc, 0x9f, 0x84,
-       0xe2, 0x31, 0x2f, 0x8b, 0xbb, 0xb2, 0x56, 0x50,
-       0x79, 0x6e, 0x64, 0x63, 0x12, 0x6a, 0xbc, 0x15,
-       0xe5, 0xb5, 0x42, 0x69, 0x53, 0xeb, 0x70, 0x0e,
-       0xe9, 0xa6, 0xa2, 0x34, 0xb6, 0x38, 0x8d, 0xc7,
-       0x09, 0xf1, 0x48, 0xe8, 0x73, 0x03, 0x0d, 0x31,
-       0xff, 0xa4, 0x8d, 0xe7, 0x8c, 0xa5, 0xa4, 0xd6,
-       0x8f, 0xad, 0xd6, 0x19, 0xc8, 0x6e, 0xa4, 0x35,
-       0xf2, 0x34, 0x81, 0x25, 0x66, 0x67, 0x46, 0x6b,
-       0xc7, 0x7a, 0x37, 0xb7, 0x74, 0xb0, 0x61, 0x8e,
-       0x0b, 0x1b, 0xe2, 0x24, 0x1b, 0x47, 0x51, 0x1d,
-       0x7c, 0x30, 0x0a, 0xb5, 0x07, 0xa6, 0xd6, 0xb7,
-       0x87, 0x68, 0x95, 0x83, 0xeb, 0x22, 0xb5, 0x79,
-       0x2c, 0xb4, 0xe6, 0x9c, 0x55, 0x5e, 0x27, 0xa8,
-       0x13, 0xee, 0xe6, 0xa6, 0xd6, 0xc0, 0xb0, 0x95,
-       0xa7, 0x45, 0x6b, 0x1e, 0x81, 0x69, 0x3f, 0x6e,
-       0xe4, 0x76, 0x07, 0x83, 0xed, 0x0f, 0x63, 0x57,
-       0x9f, 0x43, 0xe5, 0xe9, 0x6c, 0xa3, 0xd1, 0xa3,
-       0xa9, 0x51, 0x60, 0x5f, 0xbf, 0xc9, 0xb1, 0xd4,
-       0x34, 0xb7, 0xc8, 0x34, 0xd2, 0x96, 0x4b, 0x1d,
-       0x21, 0x56, 0x62, 0x4b, 0xee, 0x94, 0x22, 0x26,
-       0xa6, 0x12, 0xf9, 0xa6, 0xce, 0x67, 0xec, 0x8c,
-       0x59, 0xc0, 0x08, 0xbe, 0x02, 0xc4, 0xbf, 0x8a,
-       0x36, 0x1a, 0xfa, 0x3b, 0x68, 0x62, 0xd6, 0xd8,
-       0xd9, 0xda, 0xce, 0x17, 0x78, 0xf8, 0x57, 0xda,
-       0x34, 0x9c, 0x9e, 0xad, 0xd2, 0xb9, 0xa9, 0xa9,
-       0xc4, 0x79, 0xd7, 0x33, 0x07, 0xe2, 0xbf, 0xbb,
-       0x63, 0x59, 0x78, 0x7d, 0x1e, 0xc3, 0xa3, 0xdd,
-       0x9f, 0x97, 0x9a, 0x7f, 0xa3, 0x87, 0x4d, 0x8a,
-       0x6e, 0x9a, 0x5c, 0x8d, 0xd7, 0x7a, 0x67, 0x4d,
-       0x13, 0x1f, 0xec, 0xea, 0xb5, 0x2f, 0x01, 0x91,
-       0xea, 0x71, 0xce, 0xd3, 0xa1, 0xcd, 0xbd, 0x68,
-       0xb6, 0xed, 0x55, 0x99, 0x55, 0xe3, 0xf5, 0xba,
-       0xe7, 0x68, 0x9d, 0xa1, 0x6c, 0x78, 0x4c, 0x99,
-       0xd7, 0xa3, 0xc5, 0x78, 0xa9, 0x69, 0x28, 0x03,
-       0xde, 0x4b, 0x68, 0x18, 0xc6, 0xae, 0xd2, 0x86,
-       0x86, 0xa5, 0x32, 0x68, 0x36, 0x56, 0xa2, 0x4e,
-       0x0a, 0xdb, 0x5b, 0x69, 0x6e, 0x2b, 0xc7, 0x71,
-       0x6a, 0x7d, 0x54, 0xa8, 0xa1, 0x11, 0x66, 0x6a,
-       0x0d, 0x9a, 0x84, 0xf6, 0x09, 0x22, 0xb2, 0x15,
-       0xd6, 0x67, 0x98, 0x45, 0x68, 0x47, 0xf1, 0xde,
-       0x60, 0x0e, 0xcc, 0x22, 0x16, 0x56, 0xdc, 0xcc,
-       0xc5, 0x30, 0x5f, 0xc4, 0xf2, 0x92, 0xea, 0x71,
-       0x00, 0x89, 0xc9, 0x20, 0x0b, 0x55, 0x87, 0x91,
-       0x85, 0xcc, 0xfd, 0xa8, 0xb3, 0xd0, 0x3f, 0x31,
-       0x09, 0x5d, 0x58, 0x23, 0xdc, 0x30, 0x0d, 0xfd,
-       0xbc, 0x59, 0xe8, 0xc2, 0xea, 0x52, 0x6d, 0x4d,
-       0xda, 0xda, 0xd4, 0x76, 0xdd, 0xcc, 0x50, 0xe5,
-       0x56, 0xef, 0xb7, 0x91, 0x87, 0x5c, 0x58, 0xed,
-       0xbf, 0x09, 0xbb, 0xca, 0xa0, 0xf1, 0xb3, 0xa9,
-       0x0d, 0xcd, 0xb0, 0x70, 0x1d, 0x8c, 0x29, 0x16,
-       0x7e, 0xc9, 0x14, 0x34, 0x07, 0xe3, 0x29, 0xfc,
-       0x0b, 0xff, 0xac, 0x3c, 0x62, 0x33, 0x38, 0x9e,
-       0xba, 0x66, 0x4e, 0xc9, 0x0d, 0xa9, 0x3b, 0xda,
-       0xda, 0xb1, 0xc1, 0xd4, 0xb4, 0x74, 0xa7, 0x82,
-       0x66, 0x60, 0xd8, 0xc6, 0xb8, 0x32, 0x92, 0xf9,
-       0x8d, 0x11, 0x92, 0xc3, 0xee, 0xc5, 0x2c, 0x9c,
-       0x77, 0xb3, 0x26, 0xc2, 0x65, 0x4a, 0x48, 0x3b,
-       0xb8, 0xd9, 0x72, 0xe3, 0x6a, 0xf2, 0x7a, 0x16,
-       0xec, 0x19, 0xb8, 0xde, 0x68, 0x6c, 0xaa, 0xef,
-       0x54, 0x04, 0x07, 0xdd, 0x50, 0x21, 0x65, 0x4f,
-       0xb6, 0x00, 0x14, 0x77, 0x8d, 0x5f, 0xb9, 0x66,
-       0x4d, 0xb1, 0x5c, 0x6c, 0x3a, 0x28, 0x1e, 0x3c,
-       0x58, 0xdc, 0xb5, 0xb2, 0xab, 0x78, 0x8d, 0x2c,
-       0x1f, 0x7c, 0xe3, 0x8d, 0x6b, 0x74, 0x5c, 0x21,
-       0x8c, 0x03, 0xd1, 0x6e, 0x15, 0xed, 0xda, 0x07,
-       0x49, 0x54, 0x58, 0x6c, 0x2f, 0x2e, 0x1e, 0xb7,
-       0x66, 0xdc, 0x9a, 0xe2, 0x62, 0x68, 0x45, 0xb4,
-       0xc8, 0x60, 0x75, 0x22, 0xcd, 0x6e, 0x6f, 0x65,
-       0x91, 0xc5, 0x00, 0x5d, 0x60, 0x75, 0x3a, 0x41,
-       0x86, 0x88, 0x9d, 0x30, 0x48, 0xd6, 0x3e, 0x2d,
-       0x2d, 0xcb, 0xce, 0x56, 0x51, 0x94, 0x65, 0xbb,
-       0xe9, 0x88, 0x78, 0xf1, 0x23, 0x59, 0x3e, 0x82,
-       0x41, 0xcc, 0x4d, 0x96, 0xad, 0x2c, 0x37, 0x27,
-       0x7d, 0x3e, 0xfc, 0x86, 0xdc, 0xe4, 0x22, 0x59,
-       0x2e, 0x16, 0x9d, 0x26, 0xe4, 0x6d, 0x95, 0x41,
-       0x6e, 0x35, 0xd9, 0xed, 0x20, 0xdb, 0xed, 0x33,
-       0x30, 0x37, 0xbb, 0xdd, 0x69, 0x35, 0x89, 0x07,
-       0x11, 0xda, 0x31, 0x46, 0xb4, 0x8b, 0xf4, 0xaa,
-       0x9d, 0xdd, 0xbe, 0x46, 0xcb, 0x4d, 0x94, 0x45,
-       0xcc, 0xce, 0x6e, 0x3a, 0x2e, 0x5e, 0xbb, 0x42,
-       0xb9, 0x05, 0x28, 0xb7, 0x62, 0x2c, 0x7e, 0x57,
-       0xf1, 0x8c, 0xe2, 0xae, 0x19, 0x5d, 0x76, 0xab,
-       0x6c, 0xbf, 0xd0, 0x45, 0xa1, 0xe2, 0x2e, 0x8c,
-       0x39, 0x28, 0xaf, 0x81, 0xb6, 0x95, 0x26, 0x53,
-       0x6b, 0x97, 0x48, 0xb9, 0x61, 0x55, 0x5e, 0x6a,
-       0xb6, 0x3a, 0xad, 0x6b, 0x4c, 0x4e, 0xbb, 0x78,
-       0x8d, 0xe7, 0x66, 0xb7, 0xbf, 0x8f, 0xe4, 0x62,
-       0x28, 0x06, 0x27, 0xaf, 0x1b, 0xe5, 0xcc, 0x9f,
-       0x4e, 0x76, 0x89, 0xf2, 0xca, 0x95, 0x6d, 0x6b,
-       0xec, 0xa6, 0x7e, 0xf1, 0xbd, 0xf7, 0xe5, 0xae,
-       0x23, 0x5d, 0xc5, 0x98, 0xdb, 0x7b, 0x98, 0xc8,
-       0x84, 0xe5, 0x90, 0x9d, 0x28, 0xd0, 0xda, 0x6a,
-       0xbf, 0x26, 0xd3, 0x9f, 0x88, 0xd8, 0xc1, 0x56,
-       0xac, 0xf5, 0x1a, 0xbb, 0x75, 0xdc, 0x11, 0x53,
-       0x97, 0xb5, 0x78, 0xc6, 0x1a, 0x88, 0x8a, 0xc7,
-       0x57, 0x60, 0x0e, 0x60, 0x05, 0x7b, 0x71, 0x2b,
-       0x55, 0xc1, 0x69, 0x15, 0x4d, 0xef, 0x81, 0x6c,
-       0xc2, 0xc6, 0x91, 0x59, 0x36, 0x51, 0x08, 0x24,
-       0xcb, 0xf1, 0x75, 0x93, 0x59, 0xdd, 0x0e, 0xbe,
-       0x2d, 0x8b, 0x47, 0x5a, 0x93, 0xed, 0x72, 0xf1,
-       0xb5, 0x62, 0xbb, 0x38, 0x03, 0x63, 0xd6, 0xb0,
-       0xdc, 0x56, 0xda, 0xdf, 0x63, 0x99, 0x15, 0x23,
-       0xf6, 0x5e, 0x11, 0xd6, 0x67, 0x85, 0xdd, 0x6e,
-       0xba, 0x86, 0xb2, 0x64, 0x13, 0xd6, 0x4d, 0x2c,
-       0x3c, 0xe9, 0xc4, 0xba, 0xd9, 0x01, 0x69, 0x4c,
-       0xdd, 0xac, 0x6e, 0x6b, 0x66, 0xac, 0x91, 0x67,
-       0xc8, 0x56, 0x3b, 0x55, 0x6d, 0xa8, 0x6e, 0xb1,
-       0x76, 0x93, 0x8f, 0xa0, 0x95, 0xc8, 0xe2, 0x49,
-       0x0a, 0x16, 0x5f, 0x94, 0xed, 0x11, 0x56, 0x0e,
-       0xe7, 0x0c, 0x56, 0x37, 0x6c, 0xc7, 0xae, 0x19,
-       0xa2, 0xc9, 0x89, 0xe5, 0x68, 0x2d, 0xc6, 0xe6,
-       0xb7, 0x3b, 0x65, 0x2b, 0x31, 0x5a, 0xb1, 0xbd,
-       0xc4, 0xa5, 0x6f, 0x8b, 0x76, 0xd6, 0xb2, 0x5d,
-       0xad, 0xd4, 0x5c, 0xd4, 0x6e, 0x11, 0x6c, 0x2f,
-       0x14, 0x8a, 0xa5, 0x31, 0x0d, 0xcf, 0x8d, 0x6c,
-       0x12, 0xeb, 0x51, 0x5c, 0x7c, 0x70, 0x0d, 0xda,
-       0xa4, 0xb8, 0x46, 0xc6, 0x16, 0xb3, 0x1f, 0x7c,
-       0xc3, 0x7e, 0x6d, 0x06, 0xb5, 0x1b, 0xea, 0xd3,
-       0x6a, 0x95, 0xad, 0x07, 0xd1, 0x28, 0x4c, 0x62,
-       0xd7, 0xb8, 0x19, 0xf6, 0xd6, 0x83, 0xd8, 0xe2,
-       0xc5, 0xf6, 0x35, 0xc5, 0x56, 0x6a, 0xda, 0x22,
-       0xb2, 0xc1, 0x23, 0xdf, 0x88, 0xa0, 0x4d, 0x62,
-       0xdd, 0xec, 0x2c, 0x37, 0x6a, 0xa9, 0x95, 0x76,
-       0x4c, 0x5b, 0x3c, 0x63, 0x86, 0x81, 0xd5, 0xcd,
-       0x9c, 0x1c, 0x58, 0xf3, 0xe5, 0x9e, 0xb4, 0x50,
-       0x52, 0xfe, 0x78, 0xd3, 0x74, 0x9d, 0x61, 0x6a,
-       0x7f, 0xf6, 0x61, 0x1f, 0xed, 0x71, 0xde, 0x20,
-       0xe1, 0xda, 0xff, 0x2b, 0x0f, 0xa5, 0xf4, 0x30,
-       0x9d, 0xc1, 0x30, 0xfc, 0x35, 0xfc, 0x3d, 0xfc,
-       0x13, 0x1c, 0x84, 0x7f, 0x83, 0xcf, 0x74, 0xa3,
-       0x75, 0xb7, 0xea, 0xb2, 0x74, 0xd3, 0x75, 0xd5,
-       0xba, 0x76, 0xdd, 0xb7, 0x6e, 0xf8, 0x9a, 0xd5,
-       0xff, 0xd4, 0xed, 0xd4, 0xfd, 0xab, 0xee, 0x8a,
-       0x7e, 0xa2, 0x7e, 0xa6, 0x5e, 0xd4, 0x3f, 0xa2,
-       0x7f, 0x52, 0xff, 0xb4, 0xfe, 0x59, 0xfd, 0x0b,
-       0xfa, 0x97, 0xf5, 0xbb, 0xf5, 0xaf, 0xeb, 0x0f,
-       0xea, 0xdf, 0xd6, 0xbf, 0xa7, 0x7f, 0x5f, 0xff,
-       0xb1, 0xbe, 0x5f, 0xff, 0xa9, 0x41, 0x6f, 0x18,
-       0x61, 0x48, 0x35, 0x14, 0x1b, 0xaa, 0x0c, 0xa2,
-       0x61, 0xb9, 0x61, 0x8d, 0x61, 0x83, 0xe1, 0xef,
-       0x0d, 0x3f, 0x34, 0xfc, 0xdc, 0x70, 0x0e, 0xc0,
-       0x68, 0x31, 0x66, 0xb9, 0xd9, 0x81, 0xf8, 0x38,
-       0x51, 0xa1, 0x17, 0x68, 0xdd, 0xea, 0xfa, 0xa5,
-       0x8c, 0x9e, 0xab, 0xc4, 0x9e, 0x08, 0x54, 0x0c,
-       0xdd, 0x00, 0x83, 0x0a, 0x9c, 0x89, 0x2a, 0x38,
-       0x51, 0x2a, 0xc5, 0x65, 0x02, 0x4e, 0x61, 0xeb,
-       0x57, 0x09, 0x8b, 0x9b, 0x82, 0xed, 0x50, 0xe2,
-       0x9d, 0x8d, 0xb3, 0xfa, 0xd9, 0x79, 0xc3, 0x78,
-       0x6b, 0xfd, 0xee, 0xea, 0x05, 0xd9, 0x74, 0x6d,
-       0x68, 0xc8, 0x6e, 0x08, 0xf0, 0xc0, 0x30, 0x8e,
-       0x6a, 0x5c, 0x36, 0xa3, 0x4f, 0xc5, 0xd1, 0x7a,
-       0x41, 0x4b, 0x7b, 0xab, 0xc4, 0x53, 0xd1, 0x04,
-       0x17, 0x2a, 0x71, 0xea, 0x27, 0xe4, 0x3a, 0x71,
-       0xee, 0x55, 0xb6, 0x9c, 0x16, 0xe9, 0x58, 0x1c,
-       0x4e, 0xc2, 0xbf, 0x21, 0x92, 0x16, 0xa0, 0xe7,
-       0x3d, 0x4d, 0xec, 0xc1, 0x14, 0x94, 0xb4, 0xe3,
-       0x20, 0x43, 0x55, 0x42, 0x2a, 0xae, 0x68, 0x42,
-       0xed, 0x38, 0x0f, 0x88, 0x93, 0x8e, 0x23, 0x7f,
-       0xc3, 0x32, 0x39, 0x48, 0xc3, 0x6a, 0x39, 0xbf,
-       0x5d, 0xc5, 0xeb, 0x3a, 0xbf, 0xad, 0xa5, 0x0d,
-       0xc7, 0x1e, 0xa9, 0xb5, 0x65, 0x35, 0xce, 0xe2,
-       0x86, 0xc4, 0xd5, 0x04, 0x3a, 0x83, 0x2d, 0xed,
-       0x9d, 0x1d, 0x71, 0xa4, 0xca, 0xa6, 0x15, 0x38,
-       0xd3, 0xc8, 0x15, 0xdc, 0x9d, 0xa1, 0x76, 0xbe,
-       0x96, 0x14, 0x1c, 0xb5, 0x9e, 0xb2, 0xa9, 0xa5,
-       0x35, 0xb3, 0x3d, 0x95, 0xb3, 0xa7, 0xd6, 0xcc,
-       0x2d, 0xaf, 0x9d, 0xac, 0x32, 0xe5, 0x0d, 0x63,
-       0x2a, 0xa9, 0x70, 0x4f, 0x71, 0x4f, 0x2d, 0xab,
-       0x8b, 0x45, 0xe7, 0x0f, 0x8f, 0x9e, 0x5b, 0x5d,
-       0x5d, 0xe6, 0x9f, 0xba, 0xc0, 0x53, 0xe9, 0xae,
-       0x9a, 0x3d, 0xd5, 0x53, 0x59, 0x51, 0x5b, 0x5b,
-       0xe6, 0xd7, 0x58, 0x0b, 0x86, 0xb1, 0xba, 0xe7,
-       0x97, 0x56, 0xcc, 0x75, 0x4e, 0xc9, 0xd7, 0x62,
-       0xbf, 0x36, 0x2c, 0xd6, 0xef, 0x29, 0xa7, 0xc2,
-       0xd4, 0x2c, 0xaa, 0x2a, 0xd1, 0x18, 0x0a, 0x6f,
-       0x28, 0x88, 0x87, 0x17, 0xa4, 0x6a, 0x4e, 0x45,
-       0x5c, 0x14, 0x6b, 0x32, 0x61, 0x92, 0x53, 0x85,
-       0xb9, 0x2a, 0xcc, 0x53, 0x61, 0xbe, 0x0a, 0x0b,
-       0x54, 0xf8, 0x35, 0x15, 0x16, 0xaa, 0xf0, 0x1e,
-       0x15, 0x16, 0xa9, 0xf0, 0x5e, 0x4d, 0x4e, 0x4c,
-       0xa0, 0x26, 0x31, 0x57, 0x13, 0x99, 0xab, 0xc9,
-       0xcc, 0xd5, 0x84, 0xe6, 0x7e, 0x0d, 0xca, 0xab,
-       0x71, 0xc5, 0x22, 0xb5, 0xe1, 0x2c, 0x0f, 0x4b,
-       0x4b, 0x13, 0x4a, 0x1c, 0xe8, 0xe7, 0xe3, 0xda,
-       0xa5, 0xb1, 0x29, 0x88, 0x8d, 0x53, 0xd2, 0xde,
-       0xd6, 0xc8, 0x6e, 0xa3, 0x10, 0x5f, 0x45, 0x1b,
-       0xae, 0xc9, 0x70, 0x46, 0xe1, 0x6f, 0xea, 0x20,
-       0x03, 0x46, 0xca, 0x75, 0x96, 0x89, 0x94, 0xf9,
-       0x6d, 0x98, 0x50, 0x6e, 0x6d, 0x7f, 0x98, 0x90,
-       0xb9, 0x38, 0x77, 0xa7, 0xa9, 0x06, 0x6f, 0x76,
-       0x22, 0xac, 0x18, 0x8a, 0xac, 0xc1, 0x25, 0x12,
-       0x9a, 0x00, 0xce, 0x22, 0xaa, 0xdc, 0x55, 0x3c,
-       0x69, 0xcb, 0xf2, 0x40, 0x6b, 0xd3, 0x72, 0x5c,
-       0x8d, 0x60, 0xce, 0xa5, 0x52, 0x48, 0xa2, 0x47,
-       0x20, 0x30, 0x67, 0xce, 0x7c, 0x2a, 0x86, 0xdc,
-       0xa2, 0x74, 0x06, 0xf9, 0x9d, 0x20, 0x2e, 0x8e,
-       0xe8, 0x5a, 0xaf, 0x61, 0x19, 0x5d, 0x17, 0xa7,
-       0x76, 0x36, 0xde, 0x26, 0x31, 0xa3, 0x1c, 0x32,
-       0xc1, 0xb8, 0xbc, 0xca, 0x64, 0xb9, 0x89, 0x3f,
-       0x9e, 0x55, 0x3b, 0xe5, 0x75, 0xf1, 0x5a, 0x47,
-       0x8c, 0xef, 0x4e, 0x3d, 0xd5, 0xcb, 0xed, 0x3d,
-       0xcd, 0xa0, 0x6f, 0x4b, 0xc9, 0x83, 0x4d, 0xd5,
-       0x47, 0xdd, 0x79, 0x4e, 0x9b, 0x59, 0x31, 0xf5,
-       0xee, 0x13, 0xcc, 0x55, 0x9d, 0x42, 0x33, 0x18,
-       0xd3, 0xcd, 0xf2, 0xc9, 0x00, 0xd0, 0x97, 0xf3,
-       0x86, 0xfe, 0x31, 0x0f, 0x14, 0xf7, 0x92, 0x2f,
-       0x5d, 0x9e, 0x98, 0x15, 0x75, 0x7c, 0xf5, 0xbe,
-       0xf3, 0x17, 0xff, 0xf1, 0xef, 0x62, 0x1b, 0xfe,
-       0xcb, 0xf7, 0x54, 0x98, 0xf8, 0x9d, 0x8a, 0x2f,
-       0xc1, 0x79, 0xcb, 0x6c, 0x2c, 0xdf, 0x0c, 0xa0,
-       0x43, 0x38, 0x63, 0x61, 0xc3, 0xa9, 0xa1, 0x78,
-       0x56, 0x76, 0xdd, 0xb7, 0x27, 0x18, 0x1f, 0x8b,
-       0xfe, 0x97, 0xfe, 0xcd, 0xfc, 0x2f, 0xcd, 0x8d,
-       0x55, 0x35, 0xe9, 0xa1, 0x2d, 0x78, 0x75, 0xfd,
-       0xd9, 0xca, 0xe6, 0xe9, 0xcc, 0x2c, 0x6d, 0x92,
-       0xef, 0x31, 0x48, 0x32, 0xef, 0x4d, 0x54, 0x63,
-       0xcc, 0x3b, 0x40, 0x60, 0x9f, 0x1a, 0xbc, 0x1b,
-       0xaf, 0x49, 0x0f, 0xec, 0xd5, 0x57, 0xc2, 0xc4,
-       0x71, 0x63, 0xd2, 0xdf, 0x07, 0xf3, 0x4b, 0xbf,
-       0x81, 0xa4, 0xc4, 0x41, 0xc6, 0x8f, 0x7f, 0x77,
-       0xd2, 0xf9, 0x33, 0x2c, 0xfd, 0x03, 0x37, 0x4f,
-       0xff, 0xbf, 0x58, 0xfa, 0xc1, 0x58, 0x7a, 0xd3,
-       0xc9, 0x71, 0x3c, 0xfd, 0x03, 0x8f, 0x0d, 0x95,
-       0xe3, 0xce, 0x00, 0x8c, 0x6e, 0xd8, 0xaf, 0x0d,
-       0xff, 0x58, 0xae, 0x3d, 0xea, 0x37, 0xc9, 0x48,
-       0xee, 0x81, 0x9b, 0xca, 0xbd, 0x93, 0xe4, 0x3e,
-       0x58, 0x1b, 0x93, 0x9b, 0xa0, 0xfb, 0xad, 0x2a,
-       0xf7, 0x00, 0x45, 0x97, 0xf2, 0x6e, 0xef, 0xf2,
-       0x54, 0xd6, 0x96, 0x96, 0xba, 0x6b, 0x85, 0xd2,
-       0x39, 0xee, 0x92, 0xb9, 0x55, 0x7e, 0x61, 0x41,
-       0xf5, 0xdc, 0x1a, 0x5a, 0x1e, 0x2e, 0xf0, 0xf2,
-       0x00, 0x0e, 0x24, 0x18, 0xed, 0x17, 0x7c, 0x73,
-       0x17, 0x39, 0x89, 0x0f, 0x61, 0x2e, 0xc1, 0x92,
-       0xca, 0x3a, 0x02, 0x82, 0xbb, 0x74, 0x36, 0x4b,
-       0x57, 0x3d, 0xb7, 0x96, 0xc5, 0x23, 0xcc, 0x55,
-       0x61, 0x45, 0x55, 0x35, 0x2e, 0xb5, 0xcb, 0xfc,
-       0x2c, 0x3d, 0x8d, 0x8e, 0x8b, 0x10, 0x56, 0x54,
-       0xd5, 0x96, 0x55, 0xb9, 0x19, 0xf4, 0x97, 0xcd,
-       0x63, 0xf4, 0xea, 0x5a, 0xaf, 0xc0, 0x61, 0x25,
-       0x83, 0x95, 0x65, 0x55, 0x5a, 0xbe, 0x82, 0xe0,
-       0x2f, 0x2b, 0xaf, 0xc6, 0x64, 0xac, 0x5c, 0x0b,
-       0xb5, 0x72, 0x61, 0x00, 0x47, 0x4b, 0xcc, 0x57,
-       0x93, 0xcf, 0x60, 0x35, 0xdd, 0x22, 0xc4, 0x7c,
-       0x67, 0xd1, 0x23, 0x64, 0x2c, 0x67, 0x6d, 0x59,
-       0x4d, 0xad, 0x50, 0x43, 0xd9, 0xcc, 0x17, 0x08,
-       0xe2, 0xc8, 0xca, 0xa0, 0x97, 0x9e, 0x89, 0x21,
-       0xac, 0x9c, 0x5b, 0x35, 0x4b, 0xc0, 0xfa, 0xa3,
-       0x1c, 0xa7, 0x0a, 0x73, 0x09, 0xba, 0xcb, 0x17,
-       0xce, 0x61, 0xb0, 0x92, 0xc3, 0x12, 0x2a, 0x20,
-       0x87, 0x95, 0x04, 0x3d, 0x2a, 0xee, 0x51, 0x71,
-       0xb7, 0x8a, 0xbb, 0x55, 0xbc, 0x54, 0xc5, 0x4b,
-       0x55, 0xbc, 0xa6, 0x62, 0x71, 0x99, 0x96, 0x4f,
-       0x25, 0xc7, 0x17, 0xa8, 0x74, 0x2e, 0x77, 0xce,
-       0xdc, 0x52, 0x26, 0x4f, 0x85, 0x6e, 0x15, 0x96,
-       0x12, 0xf4, 0x97, 0x61, 0xcd, 0x16, 0x94, 0x95,
-       0x7e, 0x1e, 0xa4, 0xf4, 0xa4, 0x00, 0x4a, 0xaf,
-       0x42, 0x37, 0x41, 0x2d, 0xbe, 0xa6, 0xda, 0xef,
-       0x65, 0xf4, 0xea, 0x4a, 0x06, 0x2b, 0x2b, 0x6a,
-       0xdc, 0x15, 0xa5, 0x4c, 0xbf, 0x34, 0x41, 0x20,
-       0x3d, 0xe6, 0x56, 0x96, 0x78, 0x55, 0x58, 0x49,
-       0x30, 0x4f, 0xc5, 0xf3, 0x54, 0xdc, 0x37, 0xa7,
-       0x3a, 0x57, 0x85, 0x79, 0x04, 0x2b, 0xaa, 0x6a,
-       0x30, 0x7d, 0xc5, 0x42, 0x54, 0x61, 0x2d, 0x87,
-       0x73, 0x71, 0xd8, 0x2d, 0x2d, 0xe7, 0x38, 0x41,
-       0xc2, 0x99, 0x3d, 0x09, 0x64, 0x27, 0x0c, 0xf2,
-       0x76, 0x17, 0xd4, 0x76, 0xd7, 0xec, 0x06, 0xe1,
-       0xfc, 0x52, 0x27, 0xe5, 0xc7, 0x61, 0x25, 0x87,
-       0x68, 0x00, 0x04, 0xa9, 0x41, 0x09, 0x2e, 0x98,
-       0xcb, 0xe9, 0xf1, 0xf5, 0xd2, 0x20, 0xd2, 0x73,
-       0xd5, 0xf4, 0xb9, 0x6a, 0xfa, 0x5c, 0x35, 0x7d,
-       0xae, 0x9a, 0x3e, 0x57, 0x4d, 0x9f, 0xfb, 0x39,
-       0xe9, 0xf3, 0xd4, 0xf4, 0x79, 0x6a, 0xfa, 0x3c,
-       0x35, 0x7d, 0x9e, 0x9a, 0x3e, 0x4f, 0x4d, 0x9f,
-       0xf7, 0x39, 0xe9, 0xf3, 0xd5, 0xf4, 0xf9, 0x6a,
-       0xfa, 0x7c, 0x35, 0x7d, 0xbe, 0x9a, 0x3e, 0x5f,
-       0x4d, 0x9f, 0x7f, 0xb3, 0xf4, 0xd8, 0x2e, 0xb9,
-       0xcc, 0x5e, 0x18, 0xac, 0x24, 0x98, 0xa7, 0xe2,
-       0x79, 0x2a, 0x9e, 0xaf, 0xe2, 0xf9, 0x2a, 0x5e,
-       0xa0, 0xe2, 0x05, 0x2a, 0xfe, 0x35, 0x15, 0xff,
-       0x9a, 0x8a, 0x17, 0xaa, 0x78, 0xa1, 0x8a, 0xdf,
-       0xa3, 0xe2, 0xf7, 0xa8, 0x78, 0x91, 0x8a, 0x17,
-       0xa9, 0x38, 0xb7, 0x7f, 0x06, 0x73, 0x55, 0x98,
-       0xa7, 0xc2, 0x7c, 0x56, 0x2e, 0x66, 0x8f, 0x58,
-       0x1e, 0x15, 0x22, 0xbd, 0x40, 0x6d, 0x57, 0xc6,
-       0x97, 0xab, 0xda, 0x57, 0x9e, 0x0a, 0xf3, 0x55,
-       0x58, 0xa0, 0xc2, 0xaf, 0xa9, 0xb0, 0x50, 0x85,
-       0xf7, 0xa8, 0xb0, 0x88, 0x20, 0xda, 0xa7, 0x93,
-       0xca, 0xc3, 0x61, 0x25, 0xc1, 0x5c, 0x15, 0xcf,
-       0x55, 0xf1, 0x3c, 0x15, 0xcf, 0x53, 0xf1, 0x7c,
-       0x15, 0xcf, 0x57, 0xf1, 0x02, 0x15, 0x2f, 0x50,
-       0xf1, 0xaf, 0xa9, 0xf8, 0xd7, 0x54, 0xbc, 0x50,
-       0xc5, 0x0b, 0x55, 0xfc, 0x1e, 0x15, 0xbf, 0x47,
-       0xc5, 0x9d, 0xe8, 0x51, 0x18, 0x2c, 0x51, 0x71,
-       0x2c, 0x97, 0x5b, 0x85, 0x1e, 0x56, 0x0e, 0x1e,
-       0x9f, 0xab, 0xc6, 0xe7, 0xaa, 0xf1, 0xb9, 0x6a,
-       0x7c, 0x9e, 0x1a, 0x9f, 0xa7, 0xc6, 0xe7, 0xa9,
-       0xf1, 0x79, 0x6a, 0x7c, 0xbe, 0x1a, 0x9f, 0xaf,
-       0xc6, 0xe7, 0xab, 0xf1, 0xf9, 0x6a, 0x7c, 0x81,
-       0x1a, 0x5f, 0xa0, 0xc6, 0x17, 0xa8, 0xf1, 0x05,
-       0x6a, 0xfc, 0xd7, 0xd4, 0xf8, 0xaf, 0xa9, 0xf1,
-       0x5f, 0x53, 0xe3, 0xbf, 0xa6, 0xc6, 0x17, 0xaa,
-       0xf1, 0x85, 0x6a, 0x7c, 0xa1, 0x1a, 0x5f, 0xa8,
-       0xc6, 0xdf, 0xa3, 0xc6, 0xdf, 0xa3, 0xc6, 0xdf,
-       0xa3, 0xc6, 0x13, 0xf4, 0x94, 0xcc, 0xad, 0x9c,
-       0xeb, 0x77, 0x3a, 0x05, 0x0e, 0x73, 0x55, 0x98,
-       0xa7, 0xc2, 0x7c, 0x15, 0x16, 0xa8, 0xf0, 0x6b,
-       0x2a, 0x2c, 0x54, 0xe1, 0x3d, 0x2a, 0x2c, 0x52,
-       0xe1, 0xbd, 0x2a, 0x74, 0xab, 0xd0, 0xa3, 0xc2,
-       0x12, 0x15, 0x96, 0xaa, 0xb0, 0x4c, 0x85, 0xe5,
-       0x1c, 0xe6, 0xaa, 0xf9, 0xe7, 0xaa, 0xf9, 0xe7,
-       0xaa, 0xf9, 0xe7, 0xaa, 0xf9, 0xe7, 0xaa, 0xf9,
-       0xe7, 0xaa, 0xf9, 0xe7, 0xaa, 0xf9, 0xe7, 0xaa,
-       0xf9, 0xe7, 0xaa, 0xf9, 0xe7, 0xaa, 0xf9, 0xe7,
-       0xaa, 0xf9, 0xe7, 0xaa, 0xf9, 0xe7, 0xaa, 0xf9,
-       0xe7, 0xaa, 0xf9, 0xe7, 0xaa, 0xf9, 0xe7, 0x96,
-       0x0b, 0xde, 0xda, 0xb9, 0xb5, 0xf4, 0xac, 0xcd,
-       0x5b, 0xc3, 0xdc, 0x96, 0xe0, 0xf5, 0x30, 0x37,
-       0xc6, 0x20, 0xe1, 0x0b, 0xd4, 0xf8, 0x05, 0x6a,
-       0xfc, 0x02, 0x35, 0x7e, 0x81, 0x1a, 0x4f, 0xfe,
-       0x95, 0x28, 0x1c, 0xce, 0xad, 0x26, 0x3f, 0x4b,
-       0x38, 0x87, 0x73, 0xab, 0xbd, 0xea, 0x78, 0xe5,
-       0x55, 0xc7, 0x53, 0x4f, 0x99, 0x7b, 0x0e, 0x75,
-       0x38, 0xca, 0x8f, 0xc9, 0x51, 0xa1, 0xb7, 0xa4,
-       0x0c, 0x3d, 0xa4, 0x9f, 0xfc, 0xa9, 0xb7, 0x62,
-       0x16, 0xeb, 0x9f, 0x5e, 0xea, 0x6f, 0x24, 0x57,
-       0xb5, 0x57, 0xaf, 0xda, 0x5f, 0xbd, 0x6a, 0xff,
-       0x65, 0xf8, 0x9f, 0x1a, 0x1f, 0xae, 0x87, 0xe5,
-       0x28, 0x94, 0x6e, 0xb2, 0x57, 0xcd, 0xe5, 0xcf,
-       0x49, 0xff, 0xef, 0xcd, 0xa0, 0xd5, 0xfd, 0xc8,
-       0xfa, 0xa1, 0x37, 0x73, 0x46, 0x46, 0x60, 0xbb,
-       0xdc, 0xc5, 0x7f, 0x2b, 0xf6, 0xc2, 0xf6, 0xf5,
-       0x83, 0x9f, 0x93, 0x74, 0xdb, 0xc4, 0xe6, 0x2f,
-       0x95, 0xc5, 0x23, 0x5f, 0xad, 0x53, 0xbe, 0xfa,
-       0xfb, 0xea, 0xef, 0xab, 0xbf, 0xaf, 0xfe, 0xfe,
-       0x9b, 0xfd, 0xa5, 0x69, 0x81, 0x52, 0xe7, 0xf4,
-       0x95, 0xea, 0x9f, 0xf0, 0x97, 0x05, 0x2c, 0xee,
-       0xff, 0x3c, 0x51, 0xd5, 0x25, 0x43, 0xa2, 0x84,
-       0x9a, 0x9a, 0xea, 0x21, 0x6c, 0x7e, 0x3c, 0xb2,
-       0xc0, 0xe3, 0x1f, 0x42, 0x6a, 0x78, 0x58, 0xc0,
-       0xb9, 0x42, 0x8c, 0x68, 0xa9, 0x88, 0x67, 0x9f,
-       0x13, 0x8f, 0x94, 0xb8, 0x4b, 0xfc, 0xf1, 0x98,
-       0x3b, 0x0e, 0x9b, 0x53, 0x52, 0x58, 0xe4, 0x2c,
-       0x74, 0x5a, 0xa0, 0x59, 0xc8, 0x88, 0x11, 0x33,
-       0xfe, 0xcc, 0xeb, 0x5d, 0xd7, 0x3f, 0xfd, 0xbc,
-       0xcb, 0x02, 0xff, 0xf9, 0xef, 0x08, 0x59, 0xe0,
-       0xff, 0x8c, 0xc4, 0xe8, 0x7f, 0xa3, 0x3f, 0x80,
-       0x78, 0x35, 0xc7, 0xcd, 0x7d, 0xfe, 0xec, 0x7b,
-       0x8e, 0x43, 0xe9, 0x86, 0xda, 0xfd, 0xff, 0xf2,
-       0xfc, 0xed, 0x86, 0x7b, 0xa2, 0x7f, 0x4e, 0xfa,
-       0x9b, 0xeb, 0x61, 0xe8, 0xce, 0xdd, 0x7f, 0xdf,
-       0xd0, 0xd0, 0xdf, 0x9f, 0x68, 0x6b, 0xc3, 0x75,
-       0x75, 0x07, 0x18, 0xf1, 0x45, 0xba, 0x89, 0xbb,
-       0x13, 0x7c, 0x1a, 0xb6, 0x6d, 0x3a, 0xac, 0x0a,
-       0x29, 0x2d, 0x77, 0xfe, 0x27, 0xdd, 0x5f, 0xe6,
-       0x52, 0x75, 0xaa, 0xd4, 0xdc, 0xaf, 0x86, 0xa2,
-       0xaf, 0xfe, 0xbe, 0xfa, 0xfb, 0xea, 0xef, 0xab,
-       0xbf, 0xaf, 0xfe, 0xbe, 0xfa, 0xfb, 0xea, 0xef,
-       0xab, 0xbf, 0xaf, 0xfe, 0xbe, 0xfa, 0xfb, 0xea,
-       0xef, 0xab, 0xbf, 0xaf, 0xfe, 0xfe, 0xbf, 0xf6,
-       0xee, 0x18, 0x05, 0x61, 0x18, 0x80, 0x02, 0xe8,
-       0x55, 0x3a, 0x38, 0x4b, 0xad, 0x5b, 0x37, 0x41,
-       0xc4, 0x45, 0x74, 0x72, 0x29, 0x41, 0x8a, 0xb4,
-       0x22, 0x16, 0x11, 0xd1, 0xc3, 0x79, 0x3b, 0xdb,
-       0x52, 0x07, 0x07, 0x45, 0xa1, 0x38, 0xc8, 0x7b,
-       0x53, 0x02, 0x19, 0x02, 0xd9, 0x7e, 0xc8, 0x0f,
-       0x00, 0x00, 0x00, 0xbf, 0xf1, 0xee, 0x96, 0x19,
-       0x00, 0x00, 0x00, 0xf8, 0xcc, 0xad, 0x67, 0x5d,
-       0x53, 0xe5, 0x3a, 0x19, 0x8e, 0x93, 0xa6, 0xa0,
-       0x64, 0x52, 0xe5, 0xfb, 0x63, 0xb4, 0xc8, 0xab,
-       0xe2, 0xf0, 0xe5, 0xce, 0x56, 0xf9, 0xae, 0xd8,
-       0x8c, 0xda, 0x2f, 0x19, 0xd2, 0x2c, 0x8e, 0x43,
-       0x34, 0x6d, 0x0a, 0x68, 0xeb, 0x61, 0x78, 0xd4,
-       0x85, 0xa4, 0xd9, 0x20, 0xee, 0x84, 0x68, 0x7e,
-       0xbe, 0x3c, 0xcd, 0x67, 0xdb, 0xd3, 0x35, 0xcd,
-       0xda, 0xb6, 0xc8, 0xd0, 0x54, 0xfa, 0xd5, 0xab,
-       0x97, 0x65, 0x19, 0x9c, 0x38, 0x00, 0x00, 0x00,
-       0xfc, 0x5d, 0x7e, 0x90, 0xc8, 0x0f, 0x00, 0x00,
-       0x00, 0x40, 0x7e, 0xf0, 0x5a, 0xfb, 0x49, 0xcf,
-       0xb9, 0xef, 0xfc, 0xc0, 0x8b, 0x0e, 0x00, 0x00,
+       0x1f, 0x8b, 0x08, 0x08, 0xa8, 0xba, 0x39, 0x4d,
+       0x02, 0x03, 0x68, 0x72, 0x74, 0x6d, 0x6f, 0x6e,
+       0x2e, 0x72, 0x6f, 0x6d, 0x00, 0xec, 0xfd, 0x0f,
+       0x7c, 0x14, 0xc7, 0x91, 0x28, 0x8e, 0xd7, 0xfe,
+       0xd1, 0x6a, 0xb5, 0x2c, 0x62, 0x11, 0xb2, 0xbc,
+       0x96, 0x65, 0x18, 0x84, 0x2c, 0x0b, 0x2c, 0xc4,
+       0xea, 0x8f, 0x65, 0x19, 0x0b, 0xd8, 0x5d, 0xfd,
+       0x61, 0xb5, 0x12, 0x42, 0xac, 0x04, 0x08, 0x8c,
+       0xed, 0x19, 0xfd, 0x99, 0x41, 0x20, 0xa4, 0xcd,
+       0x6a, 0x85, 0x81, 0xe8, 0xf0, 0x82, 0x1d, 0xa2,
+       0x10, 0x3f, 0x3f, 0x4c, 0x38, 0x1f, 0xc7, 0xf9,
+       0xf9, 0x80, 0xf3, 0xf3, 0x11, 0xc7, 0xcf, 0x27,
+       0x13, 0x42, 0x30, 0xe1, 0x39, 0x0b, 0xc6, 0x18,
+       0x63, 0x42, 0x64, 0x42, 0x1c, 0xc2, 0x71, 0x06,
+       0x13, 0x8c, 0x05, 0x21, 0x44, 0x26, 0x98, 0xc8,
+       0x8a, 0xcc, 0xfe, 0xaa, 0xba, 0x67, 0x56, 0x12,
+       0x60, 0xc7, 0xb9, 0xbb, 0x77, 0xdf, 0xdf, 0xfb,
+       0xbc, 0x08, 0x76, 0xaa, 0xbb, 0xba, 0xba, 0xba,
+       0xbb, 0xba, 0xba, 0xba, 0x7a, 0xa6, 0xa7, 0xc7,
+       0x1f, 0xa9, 0x6c, 0xf7, 0xf8, 0x6a, 0xc6, 0x57,
+       0x7e, 0xa3, 0xb2, 0x5d, 0x84, 0xb8, 0xdd, 0x04,
+       0x81, 0xfd, 0xc5, 0x5f, 0xe1, 0x10, 0x46, 0xc1,
+       0xb0, 0xbf, 0xca, 0x92, 0xf9, 0x98, 0x01, 0xf4,
+       0x30, 0x1e, 0xbe, 0xe2, 0x2f, 0x6d, 0x5e, 0x89,
+       0x6f, 0xaa, 0x80, 0x84, 0xcb, 0x5a, 0x5b, 0xb2,
+       0x1a, 0xa4, 0xa0, 0x24, 0xe4, 0x64, 0xe5, 0xe6,
+       0x0a, 0x19, 0x2b, 0x56, 0x64, 0xe1, 0xff, 0x1c,
+       0x87, 0x23, 0x7f, 0xa2, 0x05, 0xc0, 0xf3, 0xc9,
+       0x93, 0x37, 0x5c, 0xfd, 0x91, 0x8e, 0xdc, 0x01,
+       0x48, 0x81, 0xed, 0xa5, 0x26, 0xeb, 0x43, 0xa0,
+       0x83, 0x6d, 0x90, 0x2e, 0x9b, 0x11, 0x93, 0xa4,
+       0x62, 0xf4, 0x51, 0x4c, 0x1e, 0x61, 0xf2, 0x0a,
+       0x21, 0x6f, 0xd3, 0x4a, 0x0a, 0x1d, 0x1c, 0x80,
+       0xaa, 0x54, 0xfd, 0xf1, 0x7d, 0xb0, 0x5d, 0x29,
+       0x9c, 0xb0, 0x1f, 0xb6, 0xcf, 0xb8, 0x41, 0x57,
+       0xa7, 0x9e, 0xe3, 0x9e, 0xe8, 0x60, 0x31, 0x13,
+       0x8f, 0x7d, 0x7b, 0x1f, 0x8b, 0x59, 0x72, 0x1e,
+       0xa2, 0x9c, 0x0b, 0x5c, 0xb9, 0x18, 0x2b, 0x35,
+       0x4e, 0x38, 0x0c, 0xdb, 0xf4, 0xbd, 0x74, 0x8d,
+       0xdb, 0xe7, 0x7d, 0x08, 0xcb, 0x99, 0x38, 0xef,
+       0x73, 0xd8, 0x5e, 0xf6, 0x0b, 0x16, 0x1e, 0xa7,
+       0x00, 0xdc, 0x60, 0xa1, 0x7b, 0x95, 0xe6, 0x09,
+       0x03, 0xf0, 0xdb, 0x10, 0xc0, 0xb6, 0xbf, 0x7b,
+       0xc1, 0xfd, 0x06, 0x5e, 0xb7, 0x62, 0x6d, 0x28,
+       0xf6, 0x52, 0xee, 0x80, 0x8e, 0xe0, 0xcb, 0x2a,
+       0xdc, 0x91, 0x3b, 0xa0, 0x27, 0xf8, 0x4a, 0xee,
+       0x80, 0x81, 0xe0, 0xab, 0xb9, 0x03, 0x46, 0x82,
+       0xaf, 0xe5, 0x0e, 0xc4, 0x10, 0xec, 0xca, 0x1d,
+       0x30, 0x11, 0xdc, 0x99, 0x3b, 0x10, 0x4b, 0x70,
+       0x97, 0x0a, 0x77, 0xe7, 0x0e, 0x94, 0x12, 0xdc,
+       0x23, 0x02, 0xac, 0x1f, 0xe4, 0x0d, 0x46, 0xce,
+       0x9b, 0x41, 0xe4, 0x0d, 0x66, 0xce, 0x1b, 0xac,
+       0x9c, 0x37, 0xd8, 0x38, 0x6f, 0x48, 0xe4, 0xbc,
+       0xc1, 0xce, 0x79, 0xa3, 0x34, 0x19, 0x6f, 0x06,
+       0x77, 0xab, 0x70, 0x0f, 0xb6, 0xe1, 0x94, 0xc0,
+       0xda, 0x40, 0xa1, 0x0d, 0x14, 0xda, 0xca, 0xda,
+       0x27, 0xc8, 0x89, 0x88, 0xf9, 0x37, 0x41, 0x50,
+       0xd3, 0xfe, 0xcd, 0x41, 0xa1, 0xad, 0x63, 0xfa,
+       0x6f, 0x18, 0x51, 0x66, 0x3e, 0x3f, 0xd8, 0x88,
+       0xea, 0x9e, 0x30, 0x96, 0x5b, 0xf1, 0x27, 0x88,
+       0x35, 0x27, 0x7a, 0x3e, 0x87, 0x58, 0x94, 0xf7,
+       0x55, 0xa9, 0xa0, 0xe2, 0xcc, 0x93, 0x37, 0xfc,
+       0x80, 0x3a, 0xb3, 0x7d, 0xe4, 0x1e, 0xd8, 0x1e,
+       0x2f, 0xe0, 0xaf, 0x13, 0xb6, 0x5b, 0x43, 0xf8,
+       0xeb, 0x41, 0x5c, 0x15, 0xc6, 0x7b, 0x61, 0xfb,
+       0xa8, 0x5a, 0xfc, 0x85, 0x61, 0xbb, 0x2d, 0x03,
+       0x7f, 0x1b, 0xf0, 0xd7, 0x27, 0xc1, 0x88, 0x2b,
+       0x7f, 0x7f, 0x34, 0x17, 0x71, 0x33, 0x7a, 0x15,
+       0x63, 0xe5, 0xaa, 0xc3, 0xba, 0x09, 0x47, 0xb1,
+       0x2f, 0xce, 0x0b, 0x15, 0x45, 0xd8, 0x03, 0xff,
+       0x92, 0xe2, 0x28, 0x84, 0x48, 0xea, 0xc9, 0x39,
+       0x87, 0x23, 0x03, 0x9a, 0x3e, 0xfe, 0xc7, 0xfe,
+       0x50, 0xaf, 0xd9, 0x3f, 0x0a, 0x93, 0xbe, 0xc3,
+       0x5f, 0xff, 0xfe, 0xfa, 0xf7, 0xd7, 0xbf, 0xff,
+       0x67, 0xff, 0x5c, 0x35, 0x0b, 0xc7, 0xa3, 0xd5,
+       0x3f, 0xc8, 0x67, 0x28, 0x3e, 0x39, 0xd5, 0xad,
+       0x14, 0x5c, 0xcd, 0x52, 0x53, 0x8b, 0x30, 0x4b,
+       0x6a, 0x6e, 0x5c, 0x2a, 0x64, 0x78, 0x5a, 0x03,
+       0x2d, 0x8d, 0x41, 0xa1, 0x55, 0x46, 0x74, 0xbd,
+       0x14, 0x0c, 0x48, 0xab, 0x26, 0x0a, 0x38, 0x1b,
+       0xe1, 0xac, 0x15, 0xb9, 0x21, 0x14, 0x26, 0xe4,
+       0xcd, 0x5b, 0xe1, 0xc5, 0x79, 0xc8, 0x99, 0x20,
+       0x5b, 0xba, 0xde, 0x40, 0x3b, 0xe6, 0xc7, 0xf9,
+       0xe2, 0xf8, 0x04, 0xb2, 0x68, 0x7e, 0x09, 0x3e,
+       0x4f, 0xaf, 0xc4, 0x79, 0xa2, 0xb3, 0xc0, 0x8b,
+       0x57, 0x28, 0x94, 0x4d, 0x14, 0xfb, 0x6f, 0x5d,
+       0x68, 0x6d, 0xb7, 0x7b, 0x7f, 0xa7, 0x58, 0xd0,
+       0xc6, 0x6e, 0x2f, 0x5f, 0x8e, 0x3f, 0xc1, 0xf1,
+       0x10, 0x59, 0xc0, 0xee, 0x42, 0x70, 0x8c, 0xc1,
+       0x9c, 0x33, 0x27, 0x11, 0xdd, 0x8f, 0xaf, 0xaa,
+       0xf3, 0x4f, 0x9e, 0xf0, 0x10, 0xd9, 0x61, 0x25,
+       0x3d, 0xdd, 0xe9, 0x1d, 0xb3, 0x44, 0x48, 0x5f,
+       0x49, 0xf6, 0x59, 0xb5, 0xd8, 0x56, 0x07, 0xa5,
+       0xed, 0xb2, 0xe5, 0x02, 0x88, 0x8c, 0xfb, 0xe6,
+       0x75, 0x74, 0x7d, 0x3e, 0x48, 0xf6, 0xf3, 0xef,
+       0x06, 0x72, 0x3b, 0x8a, 0xbf, 0x03, 0xab, 0x73,
+       0x3b, 0x40, 0xd0, 0x9d, 0xce, 0xed, 0x70, 0xac,
+       0x81, 0x67, 0xf1, 0xba, 0x1f, 0x36, 0x20, 0xa6,
+       0x00, 0x36, 0xe2, 0xb5, 0x1b, 0x36, 0xe1, 0x15,
+       0x74, 0x66, 0x76, 0xb5, 0xb0, 0xab, 0x89, 0x5d,
+       0x31, 0xef, 0x46, 0x9c, 0x86, 0x59, 0x58, 0x8f,
+       0xf6, 0x9d, 0x3c, 0x84, 0x4f, 0x9c, 0x61, 0xaa,
+       0x0b, 0xb6, 0x24, 0x4d, 0x58, 0x01, 0x46, 0xc1,
+       0x7c, 0xae, 0xb3, 0x31, 0xb9, 0xa8, 0x07, 0x52,
+       0xfd, 0x10, 0xb8, 0xb3, 0x7b, 0xc1, 0x9c, 0x77,
+       0x23, 0x03, 0xa5, 0xce, 0xae, 0xc5, 0xe0, 0x93,
+       0x8d, 0x7e, 0x10, 0xf5, 0xfe, 0x48, 0xc5, 0x19,
+       0x83, 0xbe, 0xb2, 0x1d, 0xed, 0xed, 0xb6, 0xb8,
+       0x3a, 0xf5, 0xf7, 0xec, 0x4d, 0xbf, 0xba, 0xff,
+       0xfc, 0xdf, 0x1d, 0x81, 0x9b, 0x70, 0xe2, 0xff,
+       0x99, 0x72, 0xbe, 0xfe, 0xaf, 0xb2, 0xad, 0x74,
+       0xe0, 0x3e, 0x98, 0xf0, 0x7b, 0xe6, 0xc5, 0x64,
+       0xe6, 0xfe, 0x0a, 0xaf, 0x93, 0x72, 0x7f, 0x0f,
+       0x26, 0x84, 0x0e, 0x36, 0xcf, 0x9f, 0xf9, 0xd4,
+       0x94, 0x3b, 0x30, 0x8a, 0x60, 0x88, 0xd3, 0x92,
+       0x8e, 0x94, 0x8e, 0x50, 0x0e, 0x0b, 0xb3, 0xa9,
+       0x27, 0x5f, 0xa3, 0x99, 0xf0, 0xc9, 0x9c, 0x93,
+       0xaf, 0x0f, 0xc0, 0x4b, 0xb1, 0x29, 0x35, 0x87,
+       0x23, 0xd7, 0xab, 0x10, 0x5b, 0x6a, 0x15, 0xe1,
+       0xce, 0xa9, 0xd1, 0xb9, 0xac, 0x23, 0x16, 0xcc,
+       0x9f, 0x93, 0xcf, 0x00, 0x19, 0x8a, 0x9e, 0x73,
+       0xf1, 0x7c, 0x1e, 0x89, 0xa0, 0x66, 0x05, 0x85,
+       0x29, 0xa0, 0xef, 0xda, 0x87, 0x29, 0xd0, 0x98,
+       0x84, 0x10, 0x79, 0x34, 0xc4, 0x0b, 0xa4, 0x73,
+       0x41, 0x37, 0xf5, 0x67, 0x46, 0x65, 0xdb, 0xec,
+       0xcf, 0x09, 0x2b, 0xc1, 0x17, 0x93, 0x24, 0xec,
+       0x58, 0xeb, 0x4a, 0xf4, 0x35, 0x50, 0x23, 0x97,
+       0x15, 0x54, 0xae, 0x02, 0x23, 0xd3, 0xe6, 0x53,
+       0x18, 0x8a, 0x61, 0xa1, 0x0f, 0x31, 0x64, 0x62,
+       0xa1, 0x73, 0x18, 0x8a, 0x65, 0xa1, 0x0b, 0x18,
+       0x32, 0xb0, 0xd0, 0x07, 0xd7, 0xfa, 0xae, 0x9d,
+       0xfc, 0xcc, 0x3e, 0xeb, 0x73, 0x38, 0xd3, 0x0b,
+       0x13, 0xae, 0x30, 0x3e, 0x97, 0xcd, 0x59, 0xd8,
+       0x56, 0xbd, 0xdc, 0x27, 0xe0, 0x48, 0x99, 0xd1,
+       0x95, 0xdb, 0x8d, 0xd7, 0x5d, 0x13, 0x7a, 0x50,
+       0x1a, 0xdb, 0x67, 0xec, 0x36, 0x3f, 0x04, 0x31,
+       0xf0, 0xd3, 0xb3, 0x3a, 0x39, 0x31, 0xb5, 0x90,
+       0xc6, 0x55, 0xf5, 0x1a, 0xc5, 0xe2, 0xc8, 0x82,
+       0xb1, 0xe1, 0x0e, 0xd0, 0x2b, 0x57, 0x2b, 0x17,
+       0xa3, 0x5f, 0xb6, 0x7d, 0xc6, 0x9b, 0x13, 0x3e,
+       0xa7, 0x9c, 0xf8, 0xdb, 0xcb, 0xc6, 0xca, 0xae,
+       0x70, 0x87, 0x00, 0xb2, 0x89, 0xa5, 0x75, 0xb9,
+       0x69, 0xdc, 0x1d, 0xc0, 0x3a, 0xeb, 0x58, 0x9d,
+       0x2d, 0x95, 0xab, 0xcc, 0x3a, 0x56, 0x17, 0xc2,
+       0xe9, 0x19, 0xae, 0x05, 0xeb, 0xa7, 0x67, 0xb8,
+       0x43, 0x7e, 0x40, 0xac, 0x89, 0xb0, 0xb2, 0x6d,
+       0xc2, 0x80, 0x7b, 0x6e, 0xb5, 0x0f, 0x47, 0xdc,
+       0x9d, 0x98, 0x6e, 0x16, 0xe3, 0xb5, 0x76, 0x37,
+       0xa3, 0x2f, 0x62, 0xe6, 0xf4, 0x47, 0x58, 0xc9,
+       0x7b, 0xf1, 0x77, 0x8c, 0x49, 0x6c, 0xaf, 0x96,
+       0x5b, 0x31, 0x21, 0x8d, 0x41, 0x8c, 0x9f, 0x30,
+       0x50, 0x55, 0xe4, 0x9b, 0x86, 0xbd, 0x31, 0x80,
+       0x71, 0x33, 0xcb, 0x73, 0x9c, 0x8f, 0x77, 0x25,
+       0xa9, 0x72, 0x55, 0xa7, 0x0e, 0xdb, 0xd9, 0x0c,
+       0xdb, 0x46, 0x6e, 0x19, 0xdf, 0xc1, 0x34, 0xb3,
+       0x59, 0x34, 0x4a, 0xa0, 0x5f, 0x25, 0x81, 0x61,
+       0x21, 0x4a, 0x7a, 0xde, 0x84, 0x81, 0x48, 0x84,
+       0xfa, 0xa8, 0x8c, 0x3c, 0xcf, 0xed, 0x9e, 0x5f,
+       0x2a, 0x8b, 0x99, 0x35, 0x49, 0x54, 0xe2, 0xdd,
+       0x0c, 0xba, 0x19, 0x56, 0xf4, 0xf1, 0x56, 0x73,
+       0xf9, 0x51, 0xdb, 0x15, 0xdb, 0xa2, 0x4e, 0x87,
+       0xad, 0xc7, 0x73, 0xd6, 0x53, 0xd6, 0x5f, 0x35,
+       0xbd, 0xfb, 0x9a, 0x1e, 0x26, 0xa0, 0x54, 0x3d,
+       0x69, 0x02, 0xf6, 0xf2, 0x88, 0x0b, 0x19, 0x44,
+       0x77, 0x60, 0x22, 0x96, 0x38, 0xa2, 0x07, 0x6c,
+       0x2a, 0x8f, 0x24, 0xef, 0xc0, 0x94, 0x95, 0x44,
+       0x03, 0x7a, 0x11, 0xbe, 0x38, 0x8e, 0xb5, 0x28,
+       0xc0, 0x1a, 0x3c, 0xed, 0x28, 0x7c, 0x32, 0x32,
+       0xcd, 0x09, 0x5b, 0xf0, 0xf7, 0x3c, 0xfe, 0x5e,
+       0x40, 0x9c, 0x09, 0x6b, 0xe7, 0x94, 0x20, 0xf5,
+       0xa8, 0x26, 0xd3, 0x56, 0x21, 0xda, 0x6a, 0x2b,
+       0xab, 0xc3, 0xf1, 0xca, 0x6f, 0x76, 0x1a, 0x44,
+       0x4b, 0x34, 0x6c, 0x66, 0xa1, 0x37, 0x2b, 0xc5,
+       0x2c, 0x82, 0x7b, 0xa7, 0x53, 0x8f, 0xec, 0xe2,
+       0xb5, 0x50, 0xdb, 0x93, 0x08, 0xf3, 0x43, 0x30,
+       0xe1, 0x32, 0xa4, 0x61, 0x5b, 0xf7, 0xb8, 0xfa,
+       0xab, 0x9f, 0x9d, 0xe8, 0x81, 0x34, 0xeb, 0x1b,
+       0x5a, 0xeb, 0x6f, 0x49, 0xdf, 0x42, 0xe9, 0x54,
+       0xdf, 0x19, 0xbb, 0x41, 0x2f, 0x81, 0xee, 0x99,
+       0x68, 0xaf, 0xf1, 0x52, 0x8f, 0x54, 0x7e, 0x33,
+       0x64, 0x8e, 0xd6, 0x6f, 0x6c, 0xb4, 0xe7, 0xa2,
+       0xa9, 0x9d, 0x7a, 0xd6, 0x5f, 0x87, 0x2a, 0xbf,
+       0x09, 0xfa, 0xa8, 0x3e, 0x67, 0x31, 0xdc, 0x29,
+       0xc4, 0x19, 0x59, 0xe8, 0x43, 0x0c, 0xc5, 0xb0,
+       0xd0, 0x39, 0x0c, 0x99, 0x58, 0xe8, 0x02, 0x86,
+       0x62, 0xb9, 0x16, 0x53, 0x7c, 0x33, 0x9c, 0xeb,
+       0xbc, 0xe2, 0x49, 0xcd, 0x02, 0xe3, 0xb9, 0xef,
+       0x5c, 0x29, 0xdb, 0xe9, 0xa4, 0x7e, 0x72, 0xda,
+       0x95, 0x54, 0x37, 0x83, 0xae, 0xcf, 0xc1, 0x18,
+       0x02, 0x1c, 0xa3, 0x38, 0xb6, 0x84, 0x42, 0x30,
+       0xc4, 0xa6, 0x5c, 0xe8, 0x14, 0x7e, 0x2d, 0xfc,
+       0x1a, 0x7d, 0xd6, 0x7e, 0x46, 0x79, 0xa7, 0x92,
+       0x40, 0x12, 0x40, 0xc9, 0xa5, 0x09, 0xab, 0x3e,
+       0xeb, 0xc0, 0x7a, 0xe9, 0xc4, 0x64, 0x55, 0x3f,
+       0xe2, 0x49, 0x3f, 0xc6, 0xaf, 0x24, 0xed, 0xe0,
+       0x7a, 0x01, 0x9d, 0x15, 0x9f, 0x3f, 0x19, 0x19,
+       0x3a, 0x2e, 0xd9, 0xe8, 0xfe, 0x24, 0x74, 0x98,
+       0xcb, 0xd2, 0x35, 0xe8, 0x15, 0xd7, 0xfc, 0x70,
+       0x80, 0x8d, 0x67, 0xcb, 0x0f, 0x99, 0x4d, 0x68,
+       0xd0, 0x67, 0x6c, 0xa8, 0xed, 0xac, 0x7d, 0x06,
+       0xcb, 0xbd, 0xc0, 0x7d, 0x67, 0x26, 0x87, 0x03,
+       0x83, 0x1e, 0x74, 0xc5, 0x99, 0x31, 0x3a, 0xb2,
+       0xe1, 0x91, 0x1b, 0xd2, 0x6b, 0xbc, 0x46, 0xb2,
+       0x65, 0xfc, 0x80, 0xaa, 0x93, 0x66, 0x57, 0x7f,
+       0xff, 0x22, 0xaa, 0x1b, 0xb7, 0xf4, 0xd1, 0x74,
+       0xe2, 0xd4, 0x89, 0xe9, 0x5c, 0xaa, 0x07, 0x88,
+       0xa2, 0xb2, 0x7d, 0x0a, 0x68, 0x72, 0xaf, 0x9f,
+       0x14, 0x95, 0x7b, 0x0a, 0x8d, 0x30, 0x8c, 0x19,
+       0x58, 0x4e, 0x63, 0xa8, 0xc3, 0x0c, 0xa1, 0x0e,
+       0x30, 0x93, 0xf4, 0x45, 0x23, 0x49, 0x53, 0x18,
+       0x47, 0xa5, 0xcf, 0x2c, 0xf4, 0x43, 0x59, 0x1f,
+       0xd8, 0xb2, 0x12, 0x4b, 0xfa, 0xc1, 0x97, 0xb1,
+       0xbe, 0x04, 0x25, 0x17, 0x1f, 0xae, 0x5c, 0x65,
+       0xd7, 0xf9, 0x75, 0x33, 0xaf, 0xd9, 0x21, 0x73,
+       0x4c, 0xfa, 0xa6, 0xf2, 0xdf, 0x42, 0xca, 0xa4,
+       0x3b, 0x26, 0x6d, 0x42, 0x8a, 0xb4, 0xca, 0x55,
+       0x36, 0xbd, 0x5f, 0x8f, 0x21, 0x4b, 0xef, 0x14,
+       0x0b, 0x44, 0x06, 0xfc, 0x06, 0x0c, 0xa3, 0xdc,
+       0x6c, 0x26, 0x3f, 0x8e, 0x51, 0xbb, 0xd9, 0x6f,
+       0x9a, 0xf4, 0xad, 0xf4, 0x75, 0x19, 0xdf, 0xae,
+       0x38, 0x53, 0x78, 0x0e, 0x6b, 0xe6, 0x05, 0xb4,
+       0x7c, 0x28, 0xaf, 0x3e, 0x94, 0xd4, 0xf7, 0x7b,
+       0x81, 0xcf, 0x82, 0x19, 0x65, 0x28, 0x85, 0x19,
+       0xa9, 0x27, 0x99, 0x1c, 0xfa, 0xcb, 0x18, 0x0e,
+       0x2d, 0x8c, 0xfe, 0x21, 0x27, 0xe8, 0x43, 0x1d,
+       0x21, 0x78, 0x88, 0x34, 0xbf, 0x03, 0xe5, 0xfe,
+       0x3c, 0x62, 0x53, 0x30, 0x96, 0xa2, 0x62, 0xb7,
+       0x30, 0xec, 0x16, 0xb2, 0x46, 0x18, 0x1b, 0xab,
+       0x62, 0x5f, 0x60, 0xd8, 0x17, 0x10, 0x6b, 0xc3,
+       0x98, 0x4d, 0xc5, 0xbe, 0x38, 0x91, 0x24, 0x74,
+       0x19, 0x8c, 0x15, 0x67, 0xc6, 0x31, 0x39, 0x87,
+       0x9c, 0xbc, 0xf4, 0xc9, 0x4d, 0x20, 0x80, 0x30,
+       0xad, 0x09, 0xd7, 0xad, 0x79, 0xd3, 0x9a, 0x74,
+       0xe7, 0x75, 0xe7, 0x11, 0x73, 0x16, 0xce, 0x62,
+       0xd8, 0xaa, 0xb3, 0xe2, 0x55, 0xaf, 0xd3, 0x63,
+       0xea, 0x6a, 0x58, 0x8d, 0xd7, 0x17, 0xe1, 0x45,
+       0xc4, 0x9c, 0xd6, 0x9d, 0x46, 0x9a, 0x67, 0xe1,
+       0x59, 0xbc, 0x6e, 0x84, 0x8d, 0x88, 0x19, 0xd0,
+       0x21, 0x1f, 0x9d, 0x59, 0x67, 0xc6, 0xb0, 0x49,
+       0x67, 0xc2, 0x30, 0x76, 0x00, 0xd2, 0x3f, 0x8f,
+       0x35, 0x6f, 0x82, 0x17, 0xb0, 0x4e, 0x4d, 0xb0,
+       0x05, 0xb6, 0x54, 0x9c, 0xd1, 0xb3, 0xb2, 0x21,
+       0x3c, 0x66, 0x00, 0xc2, 0xf0, 0xd3, 0xe3, 0x80,
+       0x30, 0x02, 0x3f, 0xfd, 0x05, 0x41, 0x03, 0xfc,
+       0xf4, 0x9c, 0x6e, 0x0c, 0xcd, 0x36, 0x3f, 0xbd,
+       0x42, 0xb0, 0x13, 0x7e, 0xfa, 0x3b, 0x1d, 0x4f,
+       0x7f, 0x1f, 0x48, 0x9b, 0xbd, 0x37, 0xa6, 0x75,
+       0xe0, 0x1c, 0x94, 0x87, 0xb3, 0x36, 0x70, 0x2e,
+       0x5a, 0xa8, 0x37, 0x44, 0x9a, 0x77, 0xe7, 0xdb,
+       0x4c, 0xa3, 0x7d, 0x8a, 0x89, 0xc5, 0x0e, 0xfb,
+       0x2b, 0xf8, 0x3a, 0xba, 0xda, 0xb5, 0x5c, 0x9f,
+       0x68, 0x97, 0xa0, 0x2d, 0xd5, 0xe7, 0x9c, 0xf3,
+       0x5e, 0xe4, 0xba, 0xab, 0xff, 0xf7, 0x5d, 0x82,
+       0x99, 0x68, 0x3c, 0x1f, 0x04, 0xcc, 0x12, 0x3c,
+       0x61, 0xd2, 0xe8, 0xfc, 0x53, 0x96, 0xc7, 0x12,
+       0x65, 0xa0, 0x8f, 0x53, 0x56, 0x9c, 0xd1, 0x8d,
+       0xaa, 0x6c, 0x2f, 0x1d, 0x10, 0x60, 0x70, 0xcd,
+       0x3f, 0x8d, 0x3c, 0x8e, 0xd3, 0xa2, 0x69, 0x1a,
+       0xf3, 0x5a, 0xc8, 0x9b, 0x79, 0xf7, 0xb2, 0x04,
+       0xbe, 0x45, 0x7c, 0x04, 0xd0, 0x88, 0x2c, 0xc3,
+       0xb5, 0xe2, 0x44, 0x94, 0x3c, 0x5a, 0xaa, 0x62,
+       0x3f, 0xb8, 0xae, 0xe8, 0x9c, 0x81, 0x3b, 0x84,
+       0x30, 0x79, 0x1f, 0x12, 0xc4, 0x16, 0xb3, 0x3a,
+       0xde, 0x23, 0x37, 0x4b, 0x30, 0xad, 0x93, 0x85,
+       0x93, 0x95, 0x24, 0x96, 0xeb, 0x5a, 0x80, 0xd5,
+       0x29, 0x31, 0x20, 0xc1, 0x32, 0x5c, 0x79, 0x2e,
+       0x37, 0xb1, 0xd4, 0xbb, 0x6f, 0x4a, 0xfd, 0x1e,
+       0xa6, 0x9e, 0x92, 0xa0, 0xbd, 0x47, 0x82, 0xa0,
+       0x87, 0xd9, 0x60, 0xb4, 0x92, 0x63, 0x83, 0x4c,
+       0xff, 0xf7, 0x52, 0x6d, 0x8e, 0xec, 0x93, 0xc0,
+       0x73, 0x95, 0xcd, 0x0a, 0xbb, 0x31, 0x35, 0x53,
+       0x02, 0xef, 0x69, 0x66, 0x0b, 0x92, 0x18, 0xbf,
+       0x14, 0xc5, 0x44, 0x73, 0xb3, 0x33, 0x89, 0x46,
+       0xf0, 0x5b, 0x9b, 0x24, 0x28, 0x49, 0x16, 0xc8,
+       0x76, 0xa0, 0x0d, 0xe9, 0xea, 0x80, 0xde, 0x65,
+       0x57, 0x51, 0xe2, 0x4f, 0x62, 0xfa, 0x2c, 0xd5,
+       0xbb, 0x4b, 0x56, 0xbd, 0xbb, 0x04, 0xe6, 0xdd,
+       0x59, 0xb9, 0x77, 0xc7, 0x3d, 0x39, 0x09, 0x6e,
+       0xac, 0x0b, 0x42, 0x22, 0xd1, 0x4d, 0xc8, 0x3d,
+       0x80, 0x79, 0xf2, 0xb8, 0xe6, 0x4d, 0xeb, 0x78,
+       0x0a, 0x48, 0x63, 0xc3, 0x02, 0x6c, 0xf1, 0xeb,
+       0x59, 0xd9, 0xe3, 0x59, 0xd9, 0xe3, 0x95, 0x3e,
+       0xd4, 0xf0, 0x5e, 0x56, 0xeb, 0x79, 0xcc, 0xee,
+       0xce, 0x93, 0x8d, 0x95, 0x01, 0x01, 0xc8, 0x17,
+       0xb0, 0x11, 0xc5, 0x2c, 0xea, 0x09, 0xe7, 0x3c,
+       0xc5, 0x5e, 0xcd, 0x52, 0xab, 0x5d, 0xd4, 0x66,
+       0x67, 0xad, 0xcd, 0x66, 0xeb, 0x01, 0x1d, 0x4a,
+       0xb0, 0x9f, 0xfa, 0x22, 0x01, 0xba, 0x18, 0xad,
+       0x62, 0x1b, 0x5e, 0xba, 0x68, 0x65, 0x3c, 0xf3,
+       0x96, 0x1a, 0x6d, 0xe8, 0x8d, 0x8c, 0xa1, 0x3b,
+       0x29, 0xb3, 0xc8, 0x5f, 0x75, 0x56, 0x48, 0x10,
+       0x73, 0x89, 0xcb, 0x5d, 0xc1, 0xb9, 0x03, 0xf6,
+       0x90, 0x2d, 0xb3, 0xbe, 0xc9, 0x30, 0x49, 0x0a,
+       0x44, 0x96, 0x93, 0x44, 0x3c, 0x27, 0xa8, 0x16,
+       0x7c, 0x44, 0xf1, 0xd1, 0xc6, 0x5b, 0xa3, 0xf6,
+       0x17, 0xe6, 0x08, 0x9c, 0xc4, 0x39, 0x29, 0x85,
+       0xc9, 0xb8, 0x4a, 0x82, 0xd9, 0x87, 0x67, 0x90,
+       0x4e, 0xf6, 0xae, 0x30, 0xcc, 0xc4, 0xdc, 0xde,
+       0xcb, 0xab, 0x0c, 0xde, 0xbb, 0x15, 0x4b, 0xee,
+       0x41, 0xc2, 0x49, 0xf0, 0xcd, 0xa3, 0xbe, 0xe2,
+       0x39, 0x3f, 0x8b, 0x5c, 0xc9, 0x3d, 0x43, 0xf1,
+       0xca, 0xf6, 0xa1, 0x6d, 0x56, 0xfa, 0x18, 0xcf,
+       0xda, 0xa5, 0x97, 0xa8, 0x44, 0x9e, 0xe2, 0xe7,
+       0xed, 0xaf, 0xd5, 0xa4, 0x4f, 0xed, 0x9c, 0xc2,
+       0x67, 0xad, 0xab, 0x36, 0x07, 0xda, 0xee, 0xc7,
+       0xb9, 0x6d, 0x64, 0xb3, 0xf0, 0x09, 0xf4, 0xe1,
+       0x77, 0xb0, 0x59, 0xf3, 0x04, 0xf9, 0x16, 0xa4,
+       0x01, 0x33, 0x01, 0x25, 0xb5, 0x2d, 0xb1, 0x46,
+       0x82, 0xa5, 0xc7, 0xa8, 0x3e, 0x9e, 0x0c, 0xa6,
+       0x8f, 0xbb, 0x3b, 0x62, 0x1c, 0x4c, 0xb7, 0x37,
+       0x74, 0xc0, 0x88, 0x37, 0xfe, 0x55, 0x71, 0xfa,
+       0xd6, 0x61, 0x0f, 0xf4, 0x75, 0xc4, 0x70, 0x9a,
+       0xe9, 0x2c, 0xed, 0x45, 0x4c, 0x4b, 0x3f, 0x3a,
+       0xc5, 0x2a, 0x41, 0xf9, 0x1e, 0x92, 0xf7, 0xcc,
+       0x90, 0x3f, 0x96, 0x5a, 0xd9, 0xfd, 0x74, 0xc6,
+       0xe3, 0x27, 0xc3, 0x1c, 0x83, 0x7c, 0x97, 0xcf,
+       0xf9, 0x79, 0xe4, 0x94, 0xe7, 0x9f, 0xc3, 0x50,
+       0xf1, 0x06, 0x59, 0x51, 0x4f, 0xb7, 0xd7, 0xb9,
+       0xd4, 0x9c, 0x58, 0x08, 0x82, 0x04, 0xad, 0x55,
+       0x15, 0xff, 0x08, 0x06, 0xff, 0x88, 0x54, 0x93,
+       0x47, 0x4d, 0x43, 0xfc, 0x74, 0xc4, 0x17, 0xb0,
+       0xfe, 0xab, 0xe8, 0xc2, 0xfe, 0xc0, 0x3a, 0x77,
+       0x22, 0xac, 0x94, 0xed, 0xb6, 0x7d, 0xf0, 0x24,
+       0x7a, 0x95, 0x3a, 0x9a, 0x77, 0xb9, 0x2e, 0x72,
+       0xf9, 0x63, 0xea, 0x2c, 0xb9, 0x8e, 0x52, 0xb5,
+       0x12, 0x52, 0xa9, 0x0d, 0x37, 0x0e, 0x0c, 0x40,
+       0xd5, 0x2f, 0xf6, 0x5b, 0xb3, 0xc1, 0x0b, 0x3a,
+       0xd9, 0x86, 0xb0, 0x1a, 0x7d, 0x35, 0x33, 0x42,
+       0x1f, 0x18, 0x14, 0x3b, 0x42, 0x37, 0xe2, 0x93,
+       0x54, 0x7c, 0x3c, 0xc7, 0xcb, 0x4c, 0xcb, 0x3d,
+       0xbf, 0xbc, 0x5d, 0x39, 0x7c, 0x0e, 0x11, 0xfe,
+       0x73, 0xff, 0x2c, 0xc0, 0x7c, 0x62, 0xa7, 0xa0,
+       0x54, 0x30, 0x8d, 0x17, 0xa8, 0x6f, 0x99, 0x17,
+       0x6c, 0x56, 0x67, 0x2b, 0xb3, 0x36, 0x5b, 0xa1,
+       0xed, 0x0d, 0xfb, 0x21, 0x37, 0x4c, 0x5e, 0xf5,
+       0x04, 0xba, 0x86, 0xb0, 0x9f, 0xb7, 0xc5, 0x3a,
+       0xc8, 0x1e, 0xff, 0x10, 0x67, 0xcf, 0x7b, 0x23,
+       0x6c, 0x7e, 0xc6, 0x19, 0xd1, 0x80, 0xd6, 0x92,
+       0x73, 0x95, 0xdd, 0xac, 0x05, 0x42, 0x94, 0x97,
+       0x3a, 0x33, 0x12, 0xaf, 0x9b, 0x73, 0x6b, 0xf3,
+       0xa9, 0x41, 0x47, 0x35, 0x29, 0x45, 0x0b, 0xa7,
+       0x3f, 0x46, 0xfa, 0x44, 0x96, 0x0c, 0xf5, 0x8d,
+       0xad, 0x02, 0xf9, 0xfc, 0x8d, 0x39, 0xfb, 0xc0,
+       0x38, 0xb7, 0x93, 0xdd, 0x0f, 0x3c, 0xf3, 0x29,
+       0xa8, 0xbe, 0xfe, 0xe9, 0xca, 0x6e, 0xd2, 0x35,
+       0xee, 0x23, 0xb3, 0x72, 0xc7, 0x0b, 0x53, 0x3f,
+       0x7d, 0x35, 0x6a, 0x03, 0x2b, 0xa6, 0x75, 0x6c,
+       0xd4, 0xe9, 0x60, 0x32, 0xae, 0xd8, 0xfe, 0xb8,
+       0x1f, 0x9e, 0xe5, 0x16, 0x71, 0xb2, 0x13, 0xe7,
+       0x8c, 0x0e, 0x2b, 0xae, 0xcf, 0x58, 0xdc, 0x3a,
+       0x0d, 0x6b, 0x05, 0x76, 0x5d, 0x88, 0xc1, 0x64,
+       0xdd, 0xda, 0xc9, 0x1d, 0x50, 0x08, 0x27, 0x70,
+       0xb6, 0x60, 0xeb, 0x39, 0x76, 0x1d, 0x10, 0x01,
+       0x7a, 0xa2, 0xf7, 0x4e, 0x01, 0x36, 0x11, 0x8f,
+       0xc9, 0x1d, 0x99, 0x25, 0xf0, 0x31, 0xce, 0x2d,
+       0x68, 0x5f, 0x61, 0x31, 0xd1, 0xdf, 0xdd, 0xa9,
+       0x3b, 0x3d, 0xad, 0x23, 0xc1, 0x85, 0x33, 0x8a,
+       0x9a, 0x37, 0xd2, 0xa5, 0xb3, 0x70, 0x0e, 0x78,
+       0xfd, 0x86, 0x2e, 0x8c, 0x57, 0xb3, 0xee, 0x20,
+       0x5e, 0xe3, 0x75, 0x1f, 0xe2, 0x35, 0x45, 0x77,
+       0x00, 0xaf, 0x63, 0x75, 0x87, 0xf0, 0x5a, 0xaa,
+       0x3b, 0x37, 0xad, 0x43, 0x6f, 0xd5, 0x1d, 0x66,
+       0xf4, 0x47, 0xf1, 0x6a, 0xd0, 0x61, 0x3d, 0xf5,
+       0xa0, 0x3b, 0x8f, 0xe1, 0x18, 0xdd, 0x11, 0xbc,
+       0xde, 0xa3, 0x3b, 0x86, 0x35, 0x1f, 0x8f, 0x35,
+       0xbf, 0xa9, 0xce, 0xa2, 0x67, 0xb0, 0xa5, 0x99,
+       0xbc, 0xa5, 0xc2, 0xbf, 0xaf, 0xa5, 0x83, 0x56,
+       0x64, 0xd9, 0x58, 0xd5, 0x4a, 0x99, 0x98, 0x8d,
+       0xcb, 0x43, 0x7b, 0xf4, 0x82, 0x64, 0x25, 0xce,
+       0xf0, 0x02, 0xd3, 0x4c, 0xf4, 0x0f, 0xc2, 0x87,
+       0xb8, 0xec, 0xd1, 0x26, 0xe0, 0x1c, 0x68, 0x06,
+       0xd4, 0x73, 0x3f, 0x85, 0x2f, 0xeb, 0x4a, 0xe1,
+       0x9c, 0x1d, 0xc7, 0xc9, 0x0a, 0x05, 0x6e, 0xe4,
+       0x21, 0x2c, 0xe1, 0x7a, 0xee, 0xac, 0x66, 0xfc,
+       0x37, 0xcb, 0xe4, 0x07, 0xcf, 0x60, 0x36, 0xc6,
+       0xc9, 0x2d, 0x27, 0xb7, 0xa7, 0xa3, 0x43, 0x36,
+       0xf0, 0x71, 0x0b, 0x04, 0x4b, 0x4d, 0x4c, 0x3f,
+       0x37, 0xe3, 0x5a, 0xcc, 0x44, 0x33, 0x6d, 0x40,
+       0x6f, 0xc3, 0xd5, 0x4f, 0x17, 0xfe, 0x94, 0x7e,
+       0xb4, 0xb0, 0xd7, 0xcc, 0x6f, 0x70, 0x7c, 0xc5,
+       0x99, 0x7a, 0x03, 0x9b, 0x5b, 0xc3, 0xda, 0x4c,
+       0x49, 0xf3, 0x90, 0xe7, 0x1c, 0x8e, 0xea, 0x0f,
+       0x38, 0xc6, 0x3f, 0x2e, 0x3a, 0xbf, 0xb2, 0x59,
+       0x73, 0xe9, 0x01, 0x3e, 0x6b, 0xe6, 0x31, 0xbb,
+       0x78, 0xa2, 0x10, 0x26, 0xfb, 0x13, 0x34, 0x0a,
+       0x4c, 0x7d, 0x89, 0x34, 0xd4, 0x7b, 0xd5, 0xc1,
+       0x52, 0xbb, 0x9d, 0x8e, 0x6c, 0xe8, 0xe7, 0x7c,
+       0xce, 0x79, 0x02, 0x90, 0x50, 0x08, 0x6b, 0x91,
+       0xf3, 0x4b, 0xfe, 0xd8, 0x28, 0x4f, 0x1d, 0x4b,
+       0xfd, 0x15, 0xe3, 0xbc, 0x58, 0x9b, 0x8f, 0x0d,
+       0xa3, 0xa8, 0x4e, 0x61, 0xf0, 0xc3, 0x20, 0xe7,
+       0x25, 0xc5, 0x98, 0xfa, 0x6e, 0xa4, 0xaf, 0xe2,
+       0x0c, 0x60, 0x8d, 0xb9, 0xc5, 0xb1, 0xd9, 0xb8,
+       0xcd, 0x31, 0x7d, 0x80, 0x50, 0x5c, 0x46, 0xb1,
+       0xba, 0x16, 0x0b, 0x93, 0x55, 0x25, 0x59, 0x18,
+       0x8c, 0x9f, 0x65, 0xd8, 0x73, 0x2d, 0x16, 0x26,
+       0x0f, 0x0d, 0x5b, 0x2f, 0x73, 0xaa, 0xd9, 0x6a,
+       0xfc, 0x37, 0x32, 0x4f, 0xd7, 0xe2, 0x0d, 0x8a,
+       0x09, 0xaf, 0x8d, 0x2a, 0x55, 0x95, 0x8a, 0x3d,
+       0xcf, 0xb0, 0x1f, 0xab, 0xb4, 0x1a, 0x56, 0x66,
+       0x58, 0x45, 0xa5, 0x9d, 0xa3, 0x62, 0x2f, 0x30,
+       0xec, 0x27, 0x2a, 0x2d, 0xc3, 0x62, 0xaf, 0x80,
+       0x29, 0x93, 0x6c, 0xb2, 0xb3, 0x40, 0xd5, 0x14,
+       0xd0, 0x77, 0xb2, 0xfe, 0x4d, 0x97, 0xd0, 0xbd,
+       0x25, 0x1a, 0x77, 0x35, 0x6b, 0xb1, 0x71, 0xe7,
+       0x52, 0xd0, 0xb7, 0xe0, 0x98, 0x56, 0xac, 0xd5,
+       0x18, 0xf2, 0x2d, 0xa5, 0xd5, 0xc7, 0xd2, 0x5e,
+       0xa4, 0x7d, 0x54, 0x4e, 0x60, 0x79, 0xab, 0x14,
+       0x0b, 0x59, 0xef, 0xa3, 0x8b, 0xd4, 0xf2, 0x8a,
+       0x58, 0x79, 0xc5, 0x32, 0xae, 0x9c, 0x9b, 0x93,
+       0x6e, 0xc7, 0x49, 0x3e, 0x30, 0xc8, 0xc9, 0xd4,
+       0x89, 0xdc, 0xb6, 0x23, 0xfd, 0x6c, 0x39, 0x8f,
+       0x68, 0x31, 0x76, 0x8e, 0x71, 0xad, 0x54, 0x8c,
+       0xee, 0x6a, 0x31, 0xc5, 0x5b, 0x2d, 0x27, 0xe5,
+       0xef, 0x83, 0x2a, 0xef, 0x52, 0xb2, 0xc1, 0x3c,
+       0x8f, 0xf2, 0x02, 0xe5, 0xaf, 0xae, 0xa6, 0x7e,
+       0x62, 0x16, 0x7e, 0xba, 0x9a, 0x73, 0x87, 0x9a,
+       0xd3, 0x84, 0x39, 0x66, 0x8b, 0x69, 0xd6, 0x6a,
+       0x98, 0xbd, 0x2c, 0x25, 0x7f, 0x5f, 0x24, 0x32,
+       0xb4, 0xfc, 0x6a, 0xc6, 0x43, 0x9e, 0x4e, 0xbc,
+       0x7c, 0xc4, 0x23, 0x0d, 0x79, 0x54, 0xa0, 0x35,
+       0xd8, 0xab, 0x72, 0xa9, 0x53, 0xb9, 0xd8, 0x72,
+       0xee, 0x07, 0xbd, 0x1b, 0xa9, 0xbc, 0x2e, 0xc5,
+       0x87, 0x96, 0xe3, 0x79, 0x86, 0x9f, 0xad, 0x94,
+       0xa2, 0x0d, 0x0c, 0xb9, 0xab, 0x03, 0xa3, 0xd8,
+       0x78, 0x7a, 0x41, 0xbf, 0x12, 0x46, 0x11, 0x24,
+       0x3d, 0x73, 0xbe, 0x10, 0xc6, 0xb9, 0x83, 0x69,
+       0xc4, 0x8b, 0xef, 0x87, 0xbd, 0xb6, 0x79, 0xef,
+       0x46, 0x4e, 0x4b, 0xd0, 0xf0, 0xaa, 0xab, 0x07,
+       0x66, 0x5b, 0xd1, 0xeb, 0x95, 0x8d, 0xd5, 0xd5,
+       0x22, 0x79, 0x79, 0x3a, 0xb1, 0x94, 0xb5, 0xa8,
+       0x30, 0xa8, 0x1b, 0x6c, 0x6d, 0xd0, 0x86, 0x56,
+       0x90, 0xdd, 0x13, 0x70, 0xa6, 0x79, 0x77, 0x80,
+       0x75, 0x1e, 0xce, 0xb0, 0xa1, 0xb1, 0x58, 0xd7,
+       0xdd, 0x42, 0x06, 0x58, 0x15, 0x4b, 0xaa, 0xb3,
+       0xf2, 0x39, 0x05, 0x47, 0xf4, 0x17, 0x7e, 0xf4,
+       0xa9, 0x23, 0xa2, 0x91, 0xb7, 0x64, 0x49, 0x03,
+       0x9b, 0xc7, 0x00, 0x0e, 0xf3, 0xfa, 0x2f, 0xd9,
+       0xae, 0x72, 0xb4, 0x53, 0xfd, 0x1f, 0xa4, 0x67,
+       0x42, 0x46, 0xd0, 0xef, 0x64, 0x90, 0xb5, 0xe3,
+       0x85, 0x9b, 0xdb, 0xe1, 0xfb, 0x9a, 0xed, 0xa8,
+       0x3f, 0x7f, 0x9b, 0x76, 0x54, 0x0c, 0x91, 0xed,
+       0x57, 0xb5, 0xc6, 0xa6, 0xb5, 0xa6, 0xe1, 0x18,
+       0xb6, 0xc6, 0x36, 0xd8, 0x9a, 0x81, 0xed, 0xbc,
+       0x35, 0xbc, 0x6f, 0x9b, 0x9e, 0xc7, 0xd6, 0xcc,
+       0x93, 0x97, 0x53, 0x5b, 0x4a, 0xb9, 0x07, 0x55,
+       0x88, 0xd8, 0x63, 0xa9, 0x85, 0xf4, 0xb4, 0x6a,
+       0xf8, 0x53, 0xae, 0xe3, 0x6b, 0xf9, 0xf3, 0x2d,
+       0xe4, 0xf1, 0x18, 0xd3, 0xf8, 0x7b, 0x26, 0x30,
+       0x8d, 0xc6, 0x5f, 0x21, 0x9f, 0x79, 0xc5, 0x2c,
+       0xcc, 0xbb, 0x91, 0x61, 0x0b, 0x29, 0x85, 0x2c,
+       0xc2, 0x8c, 0x1b, 0x15, 0x17, 0x71, 0xb6, 0x37,
+       0xb2, 0x9a, 0xd6, 0xc8, 0xfa, 0xfd, 0xae, 0xd4,
+       0x35, 0xc8, 0x21, 0x05, 0x29, 0x93, 0xb1, 0xec,
+       0x05, 0xb2, 0x83, 0x8d, 0x10, 0x3e, 0x2a, 0xd2,
+       0x10, 0xeb, 0x8b, 0xe6, 0x32, 0x81, 0xb1, 0x54,
+       0xcd, 0xf5, 0x96, 0x3b, 0x15, 0xed, 0xc7, 0x9f,
+       0x2e, 0x48, 0xb0, 0xf8, 0x7c, 0x74, 0x04, 0x9d,
+       0xc2, 0xfc, 0x55, 0x72, 0x15, 0xef, 0x87, 0xa6,
+       0x64, 0xee, 0x4d, 0x90, 0x75, 0x2a, 0xd5, 0x53,
+       0x7d, 0x7f, 0x71, 0x20, 0xb5, 0x90, 0xa6, 0x6e,
+       0x86, 0x31, 0xb2, 0x76, 0xe8, 0x7d, 0x6e, 0x4c,
+       0x49, 0xac, 0x76, 0xa7, 0xee, 0x9f, 0x73, 0x84,
+       0xfc, 0xf5, 0x3f, 0x6d, 0x0a, 0x70, 0x4b, 0xa3,
+       0x67, 0x4f, 0xe6, 0xd0, 0xd3, 0x5a, 0xfc, 0x34,
+       0x72, 0x9d, 0x23, 0x17, 0x10, 0x57, 0xea, 0x31,
+       0xbe, 0xf2, 0x28, 0xfd, 0xca, 0x95, 0x87, 0xbc,
+       0x23, 0xba, 0x9e, 0xd0, 0x61, 0xee, 0xb9, 0x72,
+       0x92, 0xd6, 0xa6, 0xb2, 0xcb, 0xe4, 0x91, 0xce,
+       0xda, 0x4a, 0x1e, 0xe9, 0xac, 0xc3, 0x98, 0xe6,
+       0x42, 0xcd, 0x09, 0x45, 0x5b, 0x5c, 0xa9, 0xe4,
+       0x60, 0x89, 0xe2, 0x0c, 0xe0, 0x75, 0x77, 0xa0,
+       0x06, 0x91, 0x26, 0xfc, 0x22, 0xec, 0x9f, 0x9d,
+       0x30, 0x00, 0x02, 0xad, 0x17, 0xdd, 0xd5, 0x84,
+       0x95, 0xa0, 0x71, 0xba, 0x63, 0x1c, 0x8e, 0xc5,
+       0x0b, 0xa2, 0xd3, 0x5b, 0x4d, 0x7d, 0xb4, 0x78,
+       0x12, 0xcf, 0x73, 0xfc, 0x17, 0xd5, 0x65, 0xa4,
+       0x79, 0xdc, 0x8b, 0x2a, 0xb9, 0x08, 0xba, 0xc0,
+       0xec, 0x8d, 0xd5, 0x09, 0xa7, 0x68, 0x3d, 0x42,
+       0x3c, 0x66, 0x00, 0xcf, 0xdf, 0x70, 0xc3, 0x31,
+       0x8e, 0xc6, 0xb0, 0xf2, 0x12, 0xd6, 0xa2, 0x14,
+       0x6b, 0x71, 0x84, 0xcb, 0x4d, 0xe1, 0xe3, 0xbf,
+       0x4a, 0x5e, 0xa2, 0xd6, 0x48, 0xe5, 0x3b, 0xc8,
+       0xb3, 0xe8, 0x22, 0x54, 0x95, 0x5c, 0x8c, 0x44,
+       0x02, 0x95, 0x1b, 0xab, 0x97, 0xe6, 0x8c, 0x49,
+       0x25, 0xce, 0x89, 0xfb, 0x40, 0x10, 0xd3, 0xb5,
+       0x1a, 0xdc, 0x5a, 0xbe, 0xa8, 0xbf, 0x4d, 0x0d,
+       0x3a, 0x58, 0x0b, 0xd2, 0xc4, 0x4a, 0xbc, 0x36,
+       0xbb, 0xab, 0xd3, 0xa2, 0xe5, 0x04, 0x21, 0x4f,
+       0x47, 0x3d, 0x56, 0x72, 0x35, 0x03, 0x8a, 0x2e,
+       0x41, 0x95, 0x7f, 0x4c, 0x1a, 0xf3, 0x90, 0x1c,
+       0x3a, 0xcc, 0x55, 0xea, 0x73, 0xf1, 0xd1, 0x24,
+       0xf7, 0x20, 0x7e, 0x80, 0x7a, 0x94, 0x7c, 0x5c,
+       0x96, 0x86, 0x36, 0x4f, 0x26, 0xbf, 0xf2, 0x71,
+       0x79, 0x12, 0xb5, 0x66, 0x0a, 0x5b, 0x43, 0xdd,
+       0xf9, 0xb1, 0x04, 0x22, 0xb7, 0x1e, 0xd5, 0x0a,
+       0xbb, 0xfb, 0xe4, 0xac, 0x26, 0xfc, 0x1d, 0x4b,
+       0x10, 0xbf, 0x41, 0x78, 0x1c, 0xe9, 0xdd, 0xd8,
+       0xfe, 0x17, 0xa2, 0xbd, 0x50, 0x25, 0xa3, 0x3c,
+       0xe5, 0x53, 0x83, 0xed, 0xf6, 0xb9, 0xb4, 0xd6,
+       0x60, 0xab, 0x59, 0x6b, 0x78, 0xab, 0xc7, 0x14,
+       0x0e, 0xb6, 0xa6, 0xfe, 0x35, 0x6a, 0x8d, 0x3c,
+       0x4f, 0xf4, 0xe1, 0xf5, 0xc5, 0x68, 0x6b, 0x98,
+       0xae, 0xf9, 0x5c, 0xc3, 0x5b, 0x14, 0xe9, 0xc2,
+       0xb5, 0xe7, 0x98, 0x7b, 0xc7, 0x6b, 0x6d, 0xaa,
+       0x0f, 0x54, 0xbb, 0x68, 0x04, 0xcb, 0x97, 0x10,
+       0x5b, 0x38, 0xb4, 0x45, 0xf5, 0xb5, 0xc8, 0x4d,
+       0xaf, 0xcd, 0x72, 0xb4, 0x46, 0xfb, 0xd6, 0x11,
+       0xc5, 0x88, 0x35, 0x75, 0xe2, 0x0a, 0x42, 0x9d,
+       0xf3, 0xe0, 0x80, 0x36, 0xa7, 0xc0, 0x1e, 0xa4,
+       0x4e, 0x65, 0xf5, 0xbe, 0xaa, 0xd9, 0x62, 0x16,
+       0xbb, 0xae, 0xce, 0x14, 0x3c, 0xd6, 0x9f, 0x98,
+       0x0d, 0xc0, 0x64, 0x83, 0xdc, 0xbc, 0x36, 0x05,
+       0x75, 0x76, 0xc8, 0x5c, 0xe4, 0x53, 0x0a, 0xc8,
+       0x72, 0x37, 0x2f, 0xe4, 0xed, 0x4f, 0x2b, 0x3b,
+       0xfe, 0x8b, 0x41, 0x3d, 0xfc, 0x65, 0xb8, 0x04,
+       0xfb, 0xa3, 0xec, 0x52, 0x24, 0x72, 0x47, 0xda,
+       0x1b, 0xef, 0xca, 0xfd, 0x09, 0x6b, 0x7d, 0xaa,
+       0x3e, 0xd6, 0xbd, 0x26, 0x66, 0x54, 0x7c, 0x0f,
+       0x0c, 0x58, 0xe7, 0x1c, 0x5f, 0x35, 0x72, 0xa8,
+       0x5a, 0x66, 0x1f, 0x36, 0xf3, 0xa0, 0xde, 0x8b,
+       0x1e, 0x6e, 0x67, 0xbc, 0x36, 0xf9, 0x19, 0x37,
+       0x6b, 0x8b, 0xf0, 0x38, 0x6a, 0x72, 0x2a, 0x5b,
+       0xeb, 0xf4, 0xf1, 0x3a, 0x10, 0xb7, 0x6a, 0x27,
+       0x5b, 0x09, 0xdd, 0xa0, 0x32, 0xdf, 0x0f, 0xd3,
+       0xf8, 0x2f, 0x79, 0x31, 0x30, 0x3b, 0xe1, 0x24,
+       0xc9, 0xdc, 0x6d, 0x74, 0xb1, 0xb8, 0xcd, 0xae,
+       0x98, 0xb1, 0xfd, 0x82, 0x72, 0x5d, 0x8c, 0x27,
+       0x4b, 0xcc, 0x2d, 0x9d, 0xaf, 0xb3, 0xea, 0x60,
+       0x75, 0x27, 0xdd, 0xc5, 0x19, 0xbf, 0x38, 0x00,
+       0xde, 0x04, 0x25, 0x2b, 0xdd, 0x9b, 0xea, 0x49,
+       0xba, 0x5b, 0xb1, 0xd9, 0xee, 0x92, 0x60, 0xbe,
+       0x7d, 0x37, 0x28, 0x57, 0xb1, 0x05, 0x89, 0xe2,
+       0xf9, 0xd4, 0x49, 0x60, 0xde, 0xb9, 0x0f, 0xb6,
+       0x55, 0x1f, 0x55, 0x4c, 0x13, 0x8e, 0x50, 0xde,
+       0xb4, 0x38, 0xf1, 0x3c, 0xd7, 0x0e, 0xef, 0x1a,
+       0x45, 0xf4, 0x1a, 0xe5, 0xac, 0x12, 0xaa, 0xd1,
+       0x16, 0x47, 0x02, 0xb7, 0xc4, 0x43, 0x6b, 0xe3,
+       0xaf, 0xb4, 0x31, 0x8d, 0xf4, 0xf9, 0xf4, 0x3e,
+       0x18, 0x95, 0x7b, 0x9c, 0x6c, 0x36, 0xb3, 0x81,
+       0xe5, 0x82, 0xbb, 0xbc, 0x9f, 0xaf, 0xd6, 0x4a,
+       0xe3, 0xd8, 0xd5, 0x32, 0xe1, 0xe7, 0x58, 0x9b,
+       0x06, 0xb6, 0x36, 0x18, 0xc1, 0x30, 0xd6, 0x29,
+       0x3a, 0xde, 0xa3, 0x49, 0x7f, 0x92, 0xe0, 0xb1,
+       0x78, 0x9e, 0xce, 0x52, 0x46, 0x64, 0xad, 0x82,
+       0xc5, 0x12, 0xfc, 0x61, 0x80, 0xfc, 0x77, 0x09,
+       0xb2, 0xbc, 0xec, 0xbe, 0xbb, 0x55, 0x49, 0x74,
+       0xf5, 0x43, 0xbe, 0x04, 0x8f, 0x9e, 0x73, 0xb1,
+       0xbb, 0xef, 0x7c, 0xdd, 0x7f, 0x7b, 0x8d, 0x7e,
+       0xf4, 0x4d, 0x16, 0x2f, 0x27, 0xab, 0x5e, 0xd9,
+       0x3e, 0x69, 0xd2, 0x24, 0xa1, 0xbe, 0x75, 0xd9,
+       0x32, 0xa9, 0xa5, 0x41, 0xa8, 0x0f, 0x48, 0x6d,
+       0x8b, 0x1b, 0x1b, 0x04, 0xc4, 0x59, 0xf8, 0xf3,
+       0x26, 0x9f, 0xf6, 0xe0, 0x69, 0xdb, 0x82, 0x80,
+       0x16, 0xf4, 0x44, 0x71, 0x8b, 0x8a, 0x61, 0xdb,
+       0xa3, 0x36, 0xfc, 0x55, 0xcd, 0xba, 0x0d, 0xae,
+       0x38, 0x8a, 0x7b, 0xb8, 0x1b, 0xb6, 0xc9, 0xa9,
+       0xf8, 0x3b, 0xe0, 0x8e, 0xe2, 0xa4, 0x2c, 0x2d,
+       0x58, 0x14, 0xc5, 0x89, 0x4b, 0xb4, 0x60, 0x4d,
+       0x14, 0xf7, 0xf8, 0x86, 0xe8, 0xb3, 0xf0, 0x28,
+       0xee, 0xd1, 0x7e, 0xd8, 0xf6, 0x58, 0x29, 0xfe,
+       0x3a, 0xab, 0xa2, 0xb8, 0x3d, 0x27, 0xb5, 0xe0,
+       0x8c, 0x28, 0xae, 0x76, 0x93, 0x16, 0xac, 0x88,
+       0xe2, 0x6a, 0xf4, 0x5a, 0xb0, 0x36, 0x8a, 0xab,
+       0x3e, 0xaa, 0x05, 0x67, 0x0e, 0xe2, 0x7a, 0xb4,
+       0x60, 0x69, 0x14, 0x57, 0x15, 0xcd, 0x32, 0x3b,
+       0x8a, 0x2b, 0x8c, 0xe2, 0x5c, 0x43, 0xdb, 0xab,
+       0xfe, 0x55, 0x47, 0x71, 0xd3, 0xac, 0x5a, 0x70,
+       0xce, 0x20, 0x5d, 0x54, 0x44, 0x25, 0x51, 0x5c,
+       0x5e, 0x1f, 0x6c, 0x7b, 0xe0, 0x15, 0xfc, 0x9d,
+       0x2a, 0x2d, 0xd3, 0x70, 0x73, 0x16, 0x6b, 0xc9,
+       0x3e, 0x8d, 0xe1, 0xb6, 0xb9, 0x2f, 0x6b, 0xb8,
+       0xf9, 0x83, 0xb8, 0x57, 0xa3, 0x32, 0x2d, 0x8e,
+       0xb6, 0x37, 0xa8, 0xe1, 0x8a, 0xb5, 0x86, 0x6c,
+       0x53, 0x9e, 0x8e, 0xd6, 0x79, 0x10, 0x37, 0x29,
+       0x2a, 0xfb, 0x28, 0xbf, 0xb2, 0x68, 0xdb, 0x6a,
+       0xa2, 0x74, 0xe5, 0x0b, 0xa3, 0x6d, 0x73, 0x45,
+       0xdb, 0xb6, 0x3e, 0x2a, 0xe7, 0x28, 0xae, 0x48,
+       0x8e, 0xe2, 0xa2, 0xfc, 0x6a, 0x5e, 0x89, 0xe6,
+       0xd5, 0x3a, 0x6e, 0xdb, 0x3b, 0x0e, 0x0d, 0xe7,
+       0x76, 0x47, 0xdb, 0xd1, 0x11, 0x95, 0x7d, 0x34,
+       0xaf, 0x23, 0x2a, 0xbf, 0x59, 0xf3, 0x35, 0x5c,
+       0x66, 0x54, 0x15, 0x7d, 0xd1, 0xf6, 0x36, 0x3c,
+       0x33, 0x48, 0xa7, 0x22, 0xb7, 0x4d, 0x39, 0x35,
+       0xd8, 0x36, 0x0d, 0x57, 0x16, 0x55, 0x9d, 0xd2,
+       0x32, 0xb5, 0x71, 0xdb, 0x7c, 0xab, 0xa3, 0xb2,
+       0x2a, 0xf3, 0xdd, 0x52, 0xe7, 0x2a, 0x57, 0x85,
+       0xd6, 0xe7, 0x1f, 0x68, 0xb8, 0xdc, 0xec, 0x72,
+       0x0d, 0xd7, 0x1f, 0x6d, 0x6f, 0x89, 0x56, 0x46,
+       0xe1, 0x01, 0x0d, 0x57, 0x56, 0xac, 0xf6, 0xf0,
+       0xb6, 0x07, 0xa3, 0x75, 0x2e, 0x2e, 0xd1, 0xf8,
+       0xe5, 0x67, 0x44, 0xcb, 0x88, 0xd6, 0x79, 0x48,
+       0xbf, 0xe5, 0x68, 0xf5, 0xcb, 0xbd, 0x12, 0xad,
+       0x73, 0x8e, 0x46, 0x97, 0xf7, 0x98, 0x86, 0x9b,
+       0x57, 0xa2, 0xd5, 0xf9, 0xbe, 0xf3, 0x83, 0x7d,
+       0xa4, 0x8e, 0xae, 0x6d, 0x4e, 0x67, 0x54, 0x37,
+       0x66, 0xab, 0x4d, 0xdf, 0x96, 0xb1, 0x36, 0x3a,
+       0xb6, 0x6a, 0xaa, 0x8b, 0xd4, 0x3a, 0x47, 0xf5,
+       0xbe, 0x66, 0x41, 0x55, 0x89, 0xaa, 0xf7, 0xa5,
+       0x43, 0xf2, 0x2e, 0xe0, 0xb8, 0x87, 0x7a, 0x06,
+       0xe5, 0xe2, 0xab, 0x51, 0xdb, 0x11, 0xa5, 0x2b,
+       0x2f, 0xab, 0xa8, 0x50, 0xc7, 0x51, 0x54, 0x56,
+       0xc5, 0xbe, 0xb2, 0x79, 0x25, 0x1c, 0x37, 0x28,
+       0xe7, 0x12, 0xf7, 0x5c, 0x36, 0xe6, 0xb6, 0x55,
+       0x5c, 0x8d, 0xf6, 0xdb, 0xec, 0x9a, 0xd9, 0xac,
+       0x25, 0xdb, 0x3c, 0x17, 0xa2, 0xf2, 0xab, 0xac,
+       0xe1, 0xd2, 0xda, 0xe6, 0x89, 0xca, 0xa0, 0xa4,
+       0xb6, 0xa8, 0xa4, 0x8a, 0xcb, 0x25, 0x3a, 0x3e,
+       0x66, 0x95, 0xab, 0x3d, 0xb7, 0x6d, 0x5a, 0x73,
+       0xb4, 0xce, 0x15, 0x25, 0x2e, 0x8e, 0xcb, 0x8e,
+       0xda, 0x1c, 0x5f, 0x89, 0x7b, 0xf6, 0xec, 0x1a,
+       0x56, 0x97, 0x68, 0x19, 0xa5, 0xb3, 0x7d, 0xb3,
+       0x5c, 0x0c, 0x37, 0x5f, 0x88, 0x8e, 0xf3, 0xb9,
+       0x35, 0x55, 0x73, 0x19, 0x6e, 0xea, 0x89, 0xa8,
+       0x4c, 0x4b, 0x6a, 0x66, 0xb9, 0xa8, 0xe0, 0x6d,
+       0x39, 0xd3, 0xa3, 0x36, 0x71, 0xb6, 0xaf, 0xb2,
+       0x84, 0xd1, 0x95, 0x25, 0x45, 0xcb, 0xf5, 0x94,
+       0x17, 0x57, 0x93, 0x7a, 0x6c, 0x9b, 0xb7, 0x6b,
+       0x78, 0x19, 0x73, 0xa8, 0x8c, 0x93, 0x83, 0xba,
+       0x56, 0x5d, 0x8e, 0xb4, 0xc3, 0xe8, 0x66, 0xb9,
+       0xca, 0x4b, 0x58, 0x4b, 0x86, 0xb4, 0xc3, 0x53,
+       0x52, 0x5b, 0x31, 0xbb, 0x88, 0xe8, 0xee, 0xbb,
+       0x11, 0x1d, 0xfb, 0x51, 0x1b, 0x71, 0x2c, 0xda,
+       0x97, 0xf3, 0x35, 0x63, 0xb7, 0xed, 0x3d, 0xef,
+       0xad, 0x36, 0xe2, 0x68, 0xd4, 0xfe, 0xcd, 0x8f,
+       0x8e, 0x99, 0xa3, 0xd7, 0xa3, 0xb8, 0x39, 0x51,
+       0xdc, 0xb1, 0x28, 0xae, 0x4a, 0xd3, 0xab, 0x9f,
+       0x6d, 0x1c, 0x82, 0x9b, 0xaf, 0xe2, 0x0e, 0x0c,
+       0xe2, 0xe6, 0x6b, 0x74, 0x57, 0x07, 0x71, 0x9a,
+       0x9e, 0x1e, 0x4b, 0x1d, 0xc4, 0x55, 0xcf, 0x2a,
+       0xe2, 0x38, 0xdf, 0x57, 0xee, 0x75, 0xe8, 0x07,
+       0x0b, 0xce, 0xc8, 0x36, 0x11, 0x3e, 0x37, 0xa9,
+       0xfb, 0x1d, 0x96, 0xd3, 0x86, 0x07, 0x0b, 0xd8,
+       0xec, 0x6c, 0x5e, 0xef, 0xb3, 0x65, 0x44, 0x22,
+       0x12, 0xcc, 0x6e, 0x60, 0xab, 0xd3, 0x49, 0x36,
+       0x1b, 0x86, 0x6b, 0x69, 0xbd, 0xa9, 0x24, 0x30,
+       0x8f, 0xd5, 0x4e, 0xf3, 0x5c, 0xd9, 0x2f, 0x90,
+       0x4f, 0x8a, 0x68, 0xab, 0xfa, 0x5c, 0x0d, 0x8f,
+       0x13, 0x8d, 0x78, 0xbd, 0x4f, 0x82, 0x79, 0xbb,
+       0x45, 0xe8, 0x7b, 0xd5, 0xd3, 0xb8, 0x42, 0x58,
+       0xd6, 0xda, 0xd0, 0x28, 0xb4, 0xca, 0xb2, 0x60,
+       0x81, 0xc1, 0x68, 0x0b, 0xc6, 0xe6, 0x49, 0xcd,
+       0x4d, 0x0d, 0x82, 0x14, 0x50, 0xda, 0x97, 0x35,
+       0xb6, 0x04, 0xdb, 0xa6, 0x22, 0x36, 0x53, 0x25,
+       0x5c, 0x05, 0x99, 0x74, 0xc7, 0xac, 0x58, 0x82,
+       0xea, 0x8a, 0xa5, 0x50, 0xf9, 0x4c, 0x4b, 0xd2,
+       0x24, 0x38, 0xd2, 0x11, 0xc1, 0xb5, 0x4e, 0x75,
+       0x21, 0xc6, 0x3b, 0x5a, 0x4c, 0x99, 0x70, 0x14,
+       0xe3, 0xfb, 0xbe, 0x55, 0x0f, 0x95, 0x2d, 0x42,
+       0x49, 0x6a, 0xa9, 0x54, 0xeb, 0xfd, 0xb6, 0x62,
+       0xc1, 0xb2, 0x05, 0x2c, 0x7b, 0xaa, 0x48, 0x33,
+       0x76, 0x36, 0x86, 0x1c, 0xfc, 0x3e, 0xca, 0xe6,
+       0x0e, 0x9c, 0xe9, 0xd3, 0xb0, 0x46, 0xc9, 0x45,
+       0xad, 0xed, 0xcd, 0x0d, 0x2d, 0xf7, 0x05, 0x05,
+       0xb9, 0x89, 0xe6, 0xe4, 0x56, 0xbf, 0xbf, 0x31,
+       0x30, 0xb9, 0xb9, 0xa9, 0x2d, 0x68, 0x81, 0xa2,
+       0xc1, 0x88, 0x20, 0xb7, 0xb6, 0x63, 0xb2, 0x14,
+       0x14, 0xd2, 0xc0, 0xf3, 0x89, 0xd3, 0x21, 0xc1,
+       0x6f, 0x37, 0xe6, 0x0e, 0x3c, 0x15, 0x82, 0x33,
+       0xbd, 0xcf, 0xd3, 0x5d, 0x3d, 0x09, 0xe0, 0xd4,
+       0xea, 0x48, 0xe0, 0xc6, 0xeb, 0xef, 0x36, 0x7b,
+       0x77, 0x6e, 0x50, 0x8c, 0x35, 0x9d, 0xe2, 0xb5,
+       0x34, 0x4f, 0x4d, 0x67, 0xba, 0x77, 0xc1, 0x7a,
+       0x49, 0x54, 0x7a, 0x4a, 0x2e, 0xdd, 0x80, 0x1f,
+       0xd1, 0xdd, 0x3d, 0x68, 0x36, 0xfe, 0xed, 0x11,
+       0x5c, 0x6d, 0x54, 0xc8, 0x97, 0xd1, 0xef, 0x11,
+       0x7e, 0xf4, 0x5e, 0xab, 0x31, 0xad, 0x1c, 0xe3,
+       0x85, 0x4a, 0x2f, 0x52, 0xe6, 0xcb, 0xfd, 0xb5,
+       0xeb, 0x57, 0x83, 0x60, 0xa1, 0xe7, 0xc4, 0x9b,
+       0x3b, 0xa6, 0x80, 0x9f, 0x38, 0x5f, 0x16, 0xd0,
+       0x93, 0xfd, 0xed, 0x8a, 0xdc, 0x01, 0x60, 0xe5,
+       0xe5, 0x0e, 0x3c, 0x19, 0x41, 0xf8, 0x02, 0xf9,
+       0x24, 0x15, 0x67, 0xac, 0x7a, 0xf2, 0xd6, 0xd6,
+       0x82, 0x23, 0xc1, 0x8c, 0xdc, 0x99, 0x0f, 0xd6,
+       0x5b, 0x67, 0x15, 0xe3, 0xbd, 0x4e, 0xc5, 0xd4,
+       0xd5, 0xa1, 0xbb, 0x51, 0x4f, 0x7b, 0x2d, 0xf2,
+       0x72, 0xfb, 0xa1, 0x80, 0xf2, 0x64, 0x26, 0x08,
+       0x85, 0xf0, 0x42, 0x08, 0x42, 0xab, 0x20, 0x23,
+       0x2d, 0xc4, 0x9f, 0xf6, 0xf4, 0xe8, 0xd8, 0x3d,
+       0x40, 0x84, 0xf5, 0xd7, 0x71, 0xb5, 0x7b, 0xa6,
+       0x77, 0x6c, 0xda, 0xba, 0xf0, 0x2a, 0x30, 0x57,
+       0x9c, 0x01, 0x17, 0xed, 0xab, 0xf3, 0x7c, 0x12,
+       0x0e, 0xe5, 0x14, 0x82, 0x4d, 0x1a, 0xab, 0xd8,
+       0x10, 0x1a, 0xa5, 0x24, 0xc5, 0x8c, 0xd2, 0xcc,
+       0x93, 0xa0, 0xe6, 0x5c, 0xee, 0x7e, 0xd8, 0x36,
+       0x71, 0x00, 0xd7, 0x55, 0x86, 0xca, 0x76, 0x0c,
+       0x63, 0x09, 0x5f, 0xc6, 0x33, 0x8c, 0xbc, 0x86,
+       0xcb, 0x5a, 0x12, 0xe4, 0x40, 0x63, 0xa3, 0xd0,
+       0xd4, 0x12, 0x6c, 0x0c, 0x04, 0xda, 0xfd, 0x41,
+       0x61, 0xbc, 0x85, 0x76, 0xcd, 0xf4, 0x15, 0xa2,
+       0x87, 0xdd, 0x11, 0x99, 0xc9, 0x9e, 0x8e, 0x09,
+       0xf7, 0x43, 0x48, 0x32, 0x71, 0xdf, 0x89, 0x63,
+       0xc8, 0xdf, 0xdb, 0xfc, 0x42, 0xfe, 0xfd, 0x3a,
+       0x93, 0xd9, 0x00, 0x71, 0x8a, 0x89, 0xe2, 0x5b,
+       0x5e, 0xf8, 0xe4, 0x91, 0x43, 0x1d, 0x10, 0xfb,
+       0xbb, 0xf2, 0xe3, 0x6f, 0x91, 0xaf, 0x79, 0xbf,
+       0x87, 0x64, 0x81, 0x53, 0xe2, 0x33, 0x82, 0x33,
+       0xc3, 0x23, 0x41, 0x9e, 0x58, 0xf1, 0x02, 0x18,
+       0x6a, 0x3b, 0x19, 0xb6, 0xb9, 0xab, 0x43, 0x0f,
+       0x0d, 0xfe, 0xae, 0x0e, 0xe8, 0x94, 0x4d, 0xc2,
+       0x52, 0x08, 0x89, 0xa7, 0x31, 0xbc, 0x9e, 0x85,
+       0x9f, 0x16, 0xbb, 0x51, 0x66, 0xa1, 0x65, 0x16,
+       0xbc, 0xbe, 0xd9, 0x62, 0xcc, 0x5d, 0x03, 0x80,
+       0x21, 0x93, 0x3c, 0x56, 0x2d, 0x55, 0x77, 0xfb,
+       0x32, 0xf3, 0xe0, 0x9c, 0xd7, 0x9b, 0x23, 0x80,
+       0x92, 0xf4, 0x20, 0xcf, 0x01, 0xb2, 0xb1, 0xba,
+       0x54, 0xb1, 0x8a, 0xd8, 0x03, 0x91, 0x88, 0x62,
+       0x14, 0x21, 0xb2, 0x8a, 0xed, 0x73, 0xf9, 0x0f,
+       0xfe, 0xb1, 0xa7, 0xe1, 0x51, 0xf0, 0xf5, 0xe8,
+       0x6f, 0xf3, 0xf7, 0xa5, 0xe9, 0xff, 0x4e, 0x7e,
+       0x5f, 0x92, 0xff, 0x66, 0x54, 0x04, 0x02, 0x3a,
+       0xab, 0x0d, 0xb2, 0xe4, 0x49, 0xbe, 0x4e, 0x1b,
+       0xae, 0xca, 0xcb, 0xe9, 0xfe, 0x82, 0x5b, 0x49,
+       0x09, 0xe8, 0x11, 0xce, 0x57, 0x12, 0x03, 0x46,
+       0xba, 0xf3, 0xa4, 0x58, 0x5d, 0xfd, 0xba, 0x38,
+       0x09, 0x7c, 0xeb, 0x44, 0x80, 0x81, 0x31, 0xa8,
+       0x5f, 0x93, 0x57, 0xa0, 0xa5, 0x99, 0xb7, 0x14,
+       0xbc, 0xcf, 0x2b, 0x9e, 0x92, 0x7e, 0xbd, 0xb3,
+       0xa8, 0x5f, 0xb7, 0x2b, 0x31, 0x19, 0xd7, 0x59,
+       0x1f, 0x22, 0xe5, 0x68, 0x7a, 0xf6, 0x27, 0xdc,
+       0x45, 0xcf, 0x11, 0x17, 0x4e, 0xdf, 0x55, 0x08,
+       0x3a, 0x19, 0xc7, 0xbc, 0x6e, 0x24, 0x62, 0x4b,
+       0xc5, 0x53, 0x18, 0xd7, 0xb3, 0x38, 0xae, 0xdc,
+       0x7c, 0xf9, 0xe2, 0x11, 0xd4, 0x5a, 0xf4, 0xf0,
+       0x7d, 0x99, 0x62, 0x38, 0xc3, 0x89, 0xd8, 0x16,
+       0xe4, 0x74, 0xb5, 0xa4, 0x5f, 0xf7, 0x4a, 0xed,
+       0x7a, 0xef, 0x5d, 0x4a, 0xce, 0x1b, 0x27, 0xe5,
+       0xeb, 0xd5, 0xdf, 0x59, 0xd0, 0xb9, 0x60, 0xbd,
+       0xd0, 0x03, 0xc6, 0xb4, 0x4b, 0x60, 0x4c, 0xc0,
+       0xd5, 0xb2, 0x7c, 0x15, 0x73, 0x9d, 0x91, 0x60,
+       0xce, 0x75, 0xc1, 0x4a, 0xa5, 0x2c, 0xb8, 0xa2,
+       0x5f, 0xc9, 0x9e, 0xc1, 0xef, 0x12, 0x17, 0x09,
+       0x56, 0x36, 0xe6, 0x12, 0xb4, 0xe7, 0xe1, 0x48,
+       0xd9, 0x83, 0x94, 0x47, 0x45, 0xb7, 0x04, 0xd9,
+       0x97, 0xb1, 0x84, 0x4d, 0x58, 0x82, 0x19, 0x4b,
+       0xf0, 0xf8, 0x47, 0xe1, 0xba, 0x2e, 0xd1, 0xd7,
+       0x59, 0xfb, 0x9d, 0xda, 0xf5, 0xb8, 0x4e, 0xb9,
+       0x86, 0x94, 0xff, 0x13, 0x29, 0xb7, 0x8b, 0x76,
+       0xdb, 0x5e, 0x48, 0x4e, 0x7d, 0x26, 0x6d, 0x13,
+       0x62, 0xea, 0x11, 0xb3, 0x01, 0xed, 0x93, 0x15,
+       0x4b, 0xe9, 0x14, 0xe1, 0x0f, 0xab, 0xa1, 0xac,
+       0xb9, 0xb9, 0x51, 0x91, 0x9a, 0x85, 0xb6, 0xa6,
+       0x55, 0x8d, 0x42, 0x9b, 0xbf, 0xb1, 0xbe, 0x49,
+       0x6e, 0x6a, 0x0c, 0x08, 0xe3, 0x85, 0x8c, 0xd6,
+       0x96, 0xe6, 0x95, 0x42, 0x56, 0x9d, 0x90, 0xf5,
+       0x84, 0x90, 0xd5, 0x2c, 0x48, 0xcd, 0xcd, 0xad,
+       0x4f, 0x34, 0x36, 0x4c, 0xb4, 0xc0, 0xac, 0xc6,
+       0x65, 0xad, 0x81, 0x95, 0xc2, 0x13, 0x52, 0xb0,
+       0x7e, 0x31, 0x37, 0x57, 0x59, 0x75, 0x16, 0xc8,
+       0x7a, 0x02, 0x7f, 0xcd, 0x37, 0xa5, 0xb6, 0x35,
+       0x06, 0x39, 0xc5, 0x30, 0x6c, 0x00, 0x23, 0xcb,
+       0x1b, 0x55, 0x53, 0x57, 0xd3, 0xda, 0x2a, 0xe0,
+       0x5a, 0x65, 0xa5, 0xb0, 0x6c, 0x28, 0x09, 0x8e,
+       0x53, 0x57, 0x43, 0x43, 0xa0, 0xb1, 0xad, 0x4d,
+       0x58, 0xd6, 0x8e, 0xb6, 0xb1, 0xae, 0x51, 0x68,
+       0x5c, 0xde, 0xd8, 0x12, 0xad, 0x16, 0x1a, 0xf3,
+       0xfc, 0x02, 0x87, 0xc3, 0x21, 0xf8, 0x03, 0xad,
+       0xf5, 0x48, 0xd5, 0x1a, 0x98, 0x68, 0xf9, 0xff,
+       0xf3, 0x9d, 0x7e, 0x9e, 0x4f, 0xa0, 0x97, 0x56,
+       0xf3, 0x59, 0x47, 0x95, 0x3c, 0x57, 0x7f, 0xe4,
+       0x74, 0x51, 0x7f, 0xa4, 0xaa, 0xa4, 0x3f, 0xb2,
+       0xc1, 0x6b, 0x57, 0x4c, 0xe9, 0x0b, 0xd2, 0x7e,
+       0x21, 0x5e, 0xe7, 0xcf, 0x97, 0x61, 0x65, 0x08,
+       0xd8, 0xee, 0x24, 0x75, 0x27, 0x0a, 0xed, 0xa1,
+       0x99, 0x92, 0x01, 0x69, 0x15, 0x67, 0x46, 0xa9,
+       0xcf, 0x77, 0xd0, 0x5a, 0xf6, 0x22, 0x87, 0x2d,
+       0xc8, 0x21, 0x1e, 0x39, 0x78, 0xfd, 0x50, 0xbb,
+       0x1e, 0xd7, 0xc6, 0xa5, 0xe9, 0x0b, 0xaa, 0x41,
+       0x36, 0x27, 0x8c, 0xd9, 0x99, 0xa0, 0x5c, 0x11,
+       0x13, 0x28, 0x9c, 0x33, 0x66, 0xa7, 0x4f, 0x39,
+       0x27, 0x9a, 0x52, 0xc7, 0xec, 0xdc, 0xa8, 0x9c,
+       0x9a, 0xf0, 0x1e, 0x96, 0xfe, 0x21, 0xdf, 0x47,
+       0x31, 0x7e, 0x25, 0xf1, 0x66, 0x5c, 0x0d, 0xfa,
+       0xf9, 0x4f, 0x46, 0x70, 0x36, 0xdd, 0x96, 0xf5,
+       0x6f, 0x22, 0x9c, 0x2a, 0x24, 0x0c, 0xed, 0x84,
+       0x61, 0x4f, 0x29, 0x42, 0xac, 0xc6, 0xff, 0xa6,
+       0xd0, 0xcc, 0x8b, 0x10, 0x35, 0x28, 0x09, 0x47,
+       0x4a, 0xa5, 0x30, 0x35, 0x92, 0x45, 0x9a, 0x3a,
+       0xbf, 0x98, 0xdb, 0xe5, 0xf9, 0xd4, 0x69, 0xd8,
+       0xa3, 0x6a, 0x1f, 0xd6, 0x2f, 0x96, 0x5a, 0x14,
+       0xad, 0x83, 0x5d, 0xfd, 0x37, 0x7a, 0xfd, 0xa3,
+       0xdc, 0x76, 0x5a, 0x3b, 0x73, 0x0f, 0x60, 0x76,
+       0xbc, 0x08, 0x9f, 0x1a, 0x5d, 0xcd, 0xcd, 0xc3,
+       0xfb, 0xbc, 0xa1, 0xb1, 0xb9, 0x31, 0xd8, 0xd8,
+       0x60, 0xc1, 0xf9, 0xa8, 0xfc, 0x88, 0x0c, 0x33,
+       0xd9, 0x0c, 0x55, 0x56, 0x85, 0xb1, 0x7d, 0x32,
+       0x94, 0x0e, 0xb0, 0x58, 0x4d, 0xc5, 0xe7, 0xf4,
+       0xdc, 0xb0, 0xac, 0x6a, 0x67, 0xa8, 0x15, 0x4a,
+       0x7b, 0xc8, 0x4a, 0x96, 0xd5, 0x4a, 0x30, 0x73,
+       0xb1, 0x77, 0xb4, 0x02, 0xa5, 0xd7, 0x6c, 0xa3,
+       0x15, 0xac, 0xd5, 0xcc, 0xb4, 0x84, 0xb0, 0x78,
+       0xad, 0xe2, 0x73, 0x03, 0x10, 0x25, 0x7b, 0x0e,
+       0x7a, 0x2e, 0x9d, 0x3f, 0x89, 0xaf, 0x46, 0x8b,
+       0xfd, 0x5a, 0x09, 0xcb, 0x95, 0x90, 0x8c, 0x33,
+       0x29, 0xc0, 0xd6, 0xf4, 0xce, 0x0c, 0xcf, 0x1b,
+       0xb4, 0xb3, 0x1d, 0x1a, 0xe3, 0xad, 0x6f, 0xd0,
+       0xfe, 0x2f, 0x7a, 0xd6, 0xa6, 0x24, 0x88, 0x56,
+       0x2b, 0x3d, 0x27, 0xe1, 0x31, 0x23, 0xae, 0xcc,
+       0x57, 0xdb, 0x70, 0x74, 0x49, 0x50, 0x7a, 0x68,
+       0x27, 0xc8, 0x07, 0xb3, 0xcc, 0x09, 0xc9, 0xca,
+       0x74, 0xe4, 0xf0, 0xd8, 0xd7, 0xcc, 0xed, 0x44,
+       0x8b, 0x94, 0x88, 0xb9, 0x3b, 0x77, 0x82, 0x72,
+       0x50, 0x98, 0x89, 0xf6, 0xda, 0x2f, 0xc4, 0x56,
+       0xb3, 0x7b, 0x8b, 0x33, 0x8f, 0x67, 0x77, 0x08,
+       0x02, 0x98, 0xdd, 0x19, 0x60, 0x21, 0xa9, 0xce,
+       0xc3, 0x16, 0xcd, 0xba, 0xc4, 0x68, 0x2a, 0xd8,
+       0x93, 0xa4, 0x02, 0xf4, 0x32, 0xb0, 0x7f, 0xe6,
+       0xc8, 0x88, 0x3f, 0x2e, 0xc2, 0xef, 0x0f, 0xa3,
+       0x1c, 0x17, 0x61, 0xf8, 0x90, 0x04, 0x1f, 0xad,
+       0xc7, 0xf0, 0xaf, 0x30, 0xbc, 0x17, 0x2d, 0xdb,
+       0x4a, 0xd9, 0x29, 0xc1, 0x6f, 0x16, 0xb9, 0xfa,
+       0x00, 0x67, 0xf5, 0x40, 0x44, 0x08, 0x0f, 0xff,
+       0x37, 0xe7, 0xdd, 0xc8, 0x15, 0x4c, 0xdf, 0xa8,
+       0x3d, 0x13, 0x64, 0x7b, 0xd7, 0x76, 0xe7, 0xa2,
+       0x46, 0x91, 0xbe, 0xf1, 0xe7, 0xa7, 0xc8, 0x7d,
+       0xc9, 0xd0, 0x9e, 0x69, 0xc2, 0x30, 0x0e, 0xbe,
+       0xfa, 0xe6, 0x46, 0x29, 0x40, 0x3d, 0x8a, 0x93,
+       0x6a, 0x70, 0x71, 0x23, 0x8e, 0xd8, 0xfa, 0xc5,
+       0x4d, 0x2d, 0x8d, 0x3c, 0x3d, 0xd0, 0x58, 0xd7,
+       0xda, 0x1a, 0x1c, 0x6f, 0xc9, 0x58, 0xd0, 0xda,
+       0xce, 0x31, 0x8b, 0xa5, 0xe5, 0x8d, 0x42, 0xb0,
+       0x15, 0x53, 0x9a, 0x5a, 0xda, 0x82, 0x68, 0x3a,
+       0xd4, 0x37, 0x30, 0x26, 0x5a, 0x5c, 0x81, 0x46,
+       0x61, 0x25, 0x92, 0xb5, 0xb5, 0xab, 0x81, 0x27,
+       0xa4, 0x96, 0x20, 0x91, 0xd6, 0xb7, 0xb6, 0x04,
+       0x9b, 0x5a, 0xda, 0x1b, 0x85, 0x19, 0x42, 0xc6,
+       0xca, 0x29, 0x2d, 0x13, 0x47, 0xc2, 0xd7, 0x7e,
+       0x30, 0x3b, 0x92, 0xed, 0xb2, 0x99, 0x79, 0x5c,
+       0x82, 0x12, 0x91, 0xf4, 0x00, 0x5e, 0xe0, 0x52,
+       0x25, 0xff, 0xb1, 0xc4, 0x6e, 0x0b, 0x7b, 0x6d,
+       0xf2, 0x35, 0x8e, 0xb1, 0x6e, 0x98, 0x8b, 0x8b,
+       0x5c, 0x39, 0x11, 0x3d, 0x94, 0xed, 0x23, 0xf7,
+       0xd0, 0x1d, 0xee, 0x78, 0x21, 0x8d, 0xae, 0x9d,
+       0xe2, 0x63, 0xd6, 0xaa, 0x22, 0x8f, 0x9c, 0xec,
+       0xcd, 0x40, 0x7b, 0xce, 0xd2, 0xad, 0x21, 0x4a,
+       0xb7, 0xf6, 0x50, 0xfa, 0xc8, 0x2a, 0x71, 0xba,
+       0x15, 0x3d, 0x5f, 0x9e, 0x12, 0xdf, 0x4b, 0x29,
+       0xa3, 0x6a, 0x29, 0x65, 0x54, 0x58, 0x4c, 0xb3,
+       0xe2, 0x72, 0x8a, 0xa7, 0xd8, 0x32, 0x28, 0xc5,
+       0xb6, 0x81, 0x52, 0x6c, 0x7d, 0x22, 0x59, 0xeb,
+       0x79, 0x12, 0x54, 0x8c, 0x15, 0xcd, 0xda, 0x9b,
+       0x0a, 0x88, 0x79, 0x04, 0x31, 0x56, 0xb6, 0xcf,
+       0xeb, 0x6a, 0xd7, 0x3e, 0xaa, 0x87, 0x4c, 0xfe,
+       0xeb, 0x02, 0x0a, 0x5b, 0x43, 0x2c, 0xec, 0xa3,
+       0x70, 0x7c, 0x2f, 0x0b, 0x7b, 0x29, 0x6c, 0xcb,
+       0x60, 0x61, 0x17, 0x8e, 0x05, 0xec, 0xff, 0xdf,
+       0x1d, 0xd6, 0x8c, 0xf6, 0xd2, 0xc6, 0x95, 0xcb,
+       0x24, 0xbf, 0xd0, 0x22, 0x2d, 0x6b, 0x64, 0x26,
+       0xb3, 0x3e, 0xd8, 0x3e, 0x88, 0x6d, 0x6a, 0x13,
+       0xa6, 0x0a, 0x80, 0x0d, 0x46, 0x37, 0xd3, 0x63,
+       0x81, 0x62, 0x0b, 0x94, 0x5a, 0x20, 0x08, 0x7f,
+       0x7b, 0xa4, 0x80, 0xdd, 0xa1, 0xdb, 0xcc, 0xee,
+       0x86, 0x4f, 0x35, 0xaa, 0xe3, 0x42, 0x14, 0xf4,
+       0x24, 0xa3, 0xac, 0xbe, 0xca, 0x37, 0x60, 0x7b,
+       0x6e, 0x71, 0x3a, 0x28, 0xc5, 0xa4, 0x73, 0xb9,
+       0x17, 0xb1, 0xcc, 0xc7, 0x84, 0x04, 0xd2, 0xcb,
+       0x6a, 0x27, 0xc3, 0x5c, 0x40, 0x4c, 0x85, 0x60,
+       0x09, 0xe8, 0x11, 0x93, 0xc5, 0x30, 0xbf, 0x45,
+       0xcc, 0x54, 0xa1, 0x08, 0xaf, 0x79, 0x74, 0x9f,
+       0xea, 0xbd, 0xe9, 0xd5, 0xc5, 0xb2, 0xa9, 0x20,
+       0x46, 0x82, 0x0f, 0x2f, 0xfb, 0xdc, 0xb5, 0xeb,
+       0x77, 0x75, 0x80, 0x53, 0xde, 0x8c, 0xf5, 0xb6,
+       0x61, 0x85, 0xd2, 0x00, 0xd7, 0x62, 0x5a, 0x7f,
+       0x15, 0x75, 0x51, 0x7f, 0x15, 0x65, 0x49, 0x90,
+       0xea, 0x95, 0xe7, 0x91, 0xec, 0x66, 0x1e, 0x0f,
+       0xe2, 0x0a, 0x60, 0xf1, 0xee, 0x2c, 0x50, 0x4a,
+       0x73, 0x07, 0xd8, 0xce, 0xbc, 0x94, 0x55, 0x50,
+       0x58, 0x08, 0xff, 0x28, 0x74, 0xc0, 0x3f, 0x3d,
+       0x99, 0x22, 0xc4, 0x04, 0x46, 0xe0, 0x08, 0xd9,
+       0x24, 0x67, 0x9c, 0x5a, 0x93, 0x1a, 0x8b, 0x72,
+       0x46, 0x5c, 0x7a, 0x21, 0x40, 0x12, 0x5a, 0x8d,
+       0xe6, 0x7c, 0xf5, 0xf9, 0x58, 0xb5, 0x6c, 0x9c,
+       0x73, 0x2c, 0xd2, 0x9d, 0x1a, 0x2b, 0xc1, 0x92,
+       0x4d, 0x22, 0x5c, 0xde, 0x1c, 0x2d, 0xcf, 0x49,
+       0xe5, 0xb9, 0xdf, 0x94, 0x60, 0xfc, 0x29, 0xb9,
+       0x59, 0x2d, 0x0f, 0x73, 0x2e, 0x2e, 0xc5, 0xf2,
+       0x16, 0x09, 0x33, 0xad, 0x3b, 0x60, 0x64, 0x18,
+       0x20, 0x91, 0x79, 0xf5, 0x3e, 0x09, 0xbc, 0x0d,
+       0xe2, 0x4d, 0xb5, 0xb8, 0xb9, 0xcc, 0x25, 0x9d,
+       0x72, 0xda, 0xd0, 0x9a, 0xcd, 0x3d, 0x21, 0x27,
+       0x9e, 0x5a, 0x73, 0x4b, 0x2d, 0xd0, 0xe2, 0x5d,
+       0x4e, 0x98, 0x1f, 0x68, 0x6d, 0x51, 0xd0, 0x31,
+       0x6d, 0x6e, 0xe4, 0xb3, 0x2d, 0xf6, 0x18, 0x72,
+       0x28, 0xfd, 0x50, 0xce, 0xc2, 0x3e, 0x46, 0xd3,
+       0xd1, 0x0c, 0xee, 0x24, 0xee, 0x55, 0xba, 0xe3,
+       0x99, 0xb5, 0xb3, 0xa7, 0x53, 0xfa, 0x9b, 0x72,
+       0x3c, 0xf7, 0x4b, 0x1f, 0x0c, 0x15, 0x80, 0x08,
+       0xbf, 0x3d, 0x32, 0x89, 0x56, 0x41, 0xf6, 0xd5,
+       0xb1, 0x7b, 0x79, 0xae, 0x04, 0x29, 0xb9, 0xe6,
+       0x5b, 0xda, 0x1e, 0x8e, 0xb2, 0x9d, 0x73, 0x7e,
+       0x1e, 0xe9, 0x99, 0xf0, 0x36, 0x51, 0x20, 0xed,
+       0x8b, 0xe4, 0xed, 0x92, 0xbd, 0x7b, 0xd0, 0xcf,
+       0x79, 0x70, 0x3a, 0xc7, 0x40, 0xa3, 0x60, 0x1b,
+       0x80, 0xb4, 0x80, 0xc1, 0x81, 0xbd, 0x34, 0xa7,
+       0xe7, 0xfd, 0xfd, 0x8e, 0x01, 0x21, 0xcd, 0x91,
+       0x5b, 0x05, 0x01, 0xb4, 0x55, 0x73, 0x4e, 0xbe,
+       0xbf, 0x5f, 0x18, 0x10, 0x84, 0x87, 0x85, 0x8f,
+       0x67, 0x95, 0x5d, 0xad, 0x02, 0xe1, 0xb4, 0x70,
+       0xda, 0x31, 0x60, 0x01, 0xee, 0x23, 0xf3, 0xfb,
+       0xb4, 0xae, 0x1e, 0xa8, 0xb2, 0x56, 0x35, 0x0a,
+       0xf2, 0xd8, 0x1a, 0xb2, 0x89, 0xc9, 0x73, 0x43,
+       0x4b, 0x13, 0x27, 0x81, 0xb4, 0x21, 0x5a, 0x8f,
+       0x49, 0x74, 0x87, 0x96, 0xde, 0xc8, 0xe1, 0xf4,
+       0x53, 0x80, 0xed, 0x52, 0x31, 0xce, 0x75, 0xf2,
+       0x7b, 0xaa, 0xc2, 0x38, 0x96, 0x3b, 0x8b, 0x72,
+       0x97, 0x9c, 0xae, 0x09, 0xa9, 0x12, 0x18, 0x8b,
+       0x3c, 0xd0, 0xea, 0xd5, 0x7c, 0x8b, 0xb7, 0x80,
+       0x78, 0x68, 0x1c, 0x3d, 0x27, 0x89, 0x9b, 0xd6,
+       0x93, 0xae, 0xe5, 0xd4, 0x93, 0xce, 0x6b, 0xbc,
+       0x0f, 0x25, 0x08, 0x3c, 0x26, 0xc2, 0xa5, 0x2e,
+       0x1a, 0x83, 0xe5, 0x02, 0xf6, 0x1d, 0xae, 0xbd,
+       0x3c, 0x3b, 0xd0, 0x03, 0xbb, 0x0c, 0x49, 0x2c,
+       0x47, 0x28, 0xad, 0xcc, 0x1f, 0x3b, 0xf8, 0xe4,
+       0xc0, 0x8f, 0x2b, 0x4e, 0x51, 0x9f, 0x70, 0x52,
+       0x9d, 0x93, 0xfe, 0x01, 0xa9, 0x57, 0xf1, 0x72,
+       0xd0, 0x06, 0xa3, 0xd5, 0xf0, 0x34, 0x23, 0xf6,
+       0xef, 0xac, 0xaf, 0xc2, 0xb6, 0xbf, 0x6d, 0x01,
+       0xab, 0x42, 0x63, 0x6f, 0x33, 0x62, 0xe7, 0x09,
+       0x99, 0x60, 0xa4, 0x91, 0x50, 0xb5, 0x18, 0x31,
+       0x4b, 0x11, 0x53, 0x8c, 0x18, 0x33, 0xc3, 0xac,
+       0x12, 0x12, 0xe5, 0x67, 0xb1, 0x0e, 0x99, 0x93,
+       0x27, 0x4f, 0x16, 0x2a, 0x69, 0x40, 0x4e, 0x1e,
+       0xfc, 0xc3, 0xb0, 0x50, 0xdc, 0xb8, 0xbc, 0xa9,
+       0x9e, 0xb0, 0xf4, 0xbf, 0xb4, 0x29, 0x80, 0x5e,
+       0x8d, 0xbb, 0xb9, 0xb5, 0x7e, 0xa9, 0x10, 0xa5,
+       0xa8, 0xac, 0x63, 0x88, 0xb6, 0x68, 0x4e, 0x0b,
+       0xb7, 0x81, 0x43, 0x2d, 0x21, 0x0b, 0x97, 0x15,
+       0x97, 0x0c, 0x8d, 0x96, 0x36, 0xe3, 0x2a, 0x72,
+       0x25, 0x8b, 0x02, 0xdf, 0xd3, 0x25, 0xa3, 0x87,
+       0x0b, 0x3b, 0x70, 0x26, 0x7c, 0x49, 0x84, 0x8b,
+       0x5b, 0xd4, 0x77, 0xc7, 0x48, 0xa7, 0x5f, 0x46,
+       0xdc, 0x06, 0x31, 0x99, 0xef, 0xdd, 0x67, 0x98,
+       0x37, 0x10, 0xb3, 0x9a, 0x76, 0x5f, 0xc2, 0x11,
+       0x0c, 0x05, 0x69, 0x3c, 0xef, 0xb4, 0xd1, 0xac,
+       0x53, 0x6e, 0x53, 0x92, 0x02, 0xd8, 0x1b, 0xa2,
+       0x20, 0xc7, 0xa3, 0x9f, 0xb9, 0x1a, 0x53, 0xd1,
+       0x96, 0x41, 0x98, 0x68, 0x75, 0xd8, 0x6b, 0x33,
+       0x3d, 0x43, 0x68, 0xed, 0x48, 0x8b, 0x1e, 0xf0,
+       0xe3, 0xd7, 0x18, 0xed, 0x1a, 0x4c, 0x9d, 0x84,
+       0xb4, 0x9b, 0x18, 0xed, 0x77, 0x31, 0x96, 0x82,
+       0xf3, 0x11, 0xa8, 0x5c, 0x2d, 0x3c, 0x9f, 0x84,
+       0xda, 0x22, 0x42, 0xcf, 0x40, 0x65, 0x2b, 0x6b,
+       0x0f, 0x5b, 0xa3, 0xc9, 0x52, 0x7d, 0xa3, 0x05,
+       0x4a, 0x2a, 0xaa, 0x5d, 0x35, 0x42, 0x51, 0x71,
+       0x6e, 0x8e, 0x50, 0x15, 0x68, 0x15, 0x66, 0xb5,
+       0x36, 0xb4, 0xe3, 0x90, 0xb9, 0x89, 0x68, 0xa6,
+       0xb4, 0x12, 0x91, 0xae, 0xec, 0x1c, 0x74, 0x02,
+       0x6f, 0x9f, 0x94, 0xe7, 0xb8, 0x35, 0x09, 0xca,
+       0x58, 0xd9, 0x58, 0x2b, 0xf4, 0x80, 0x4b, 0xd7,
+       0xa1, 0x7e, 0xe4, 0x3f, 0xd4, 0x81, 0xe8, 0x45,
+       0xde, 0x2a, 0xb2, 0xb0, 0xba, 0x52, 0xc4, 0xfa,
+       0x51, 0x16, 0xb8, 0xea, 0x2f, 0x5d, 0x8c, 0xa9,
+       0x89, 0x2c, 0x35, 0x5d, 0x4d, 0xcd, 0xb0, 0xda,
+       0x51, 0x6a, 0xfd, 0xd5, 0x9d, 0xa9, 0x1e, 0xef,
+       0x5d, 0xf2, 0xc0, 0x98, 0x0e, 0xb0, 0xd0, 0xfd,
+       0x81, 0xd2, 0xe9, 0x98, 0xe3, 0x34, 0xc2, 0x7c,
+       0x47, 0x26, 0xe8, 0x69, 0x04, 0x55, 0x92, 0xfe,
+       0x9c, 0x42, 0x4c, 0x1a, 0x62, 0x4c, 0x0c, 0xb3,
+       0x10, 0x31, 0x27, 0x11, 0x93, 0x80, 0x18, 0x2b,
+       0xc3, 0x78, 0x10, 0xf3, 0xaf, 0x88, 0x81, 0x40,
+       0x0c, 0x51, 0x85, 0x2f, 0x83, 0x15, 0x7f, 0xfa,
+       0xc0, 0x88, 0x73, 0x3b, 0x58, 0x3a, 0x69, 0xdd,
+       0x7b, 0x38, 0x3a, 0xce, 0x56, 0xb6, 0x93, 0xfa,
+       0x04, 0x9a, 0x70, 0x4e, 0x75, 0x60, 0x27, 0x4f,
+       0x45, 0xa7, 0xb7, 0xb1, 0xad, 0xb1, 0x25, 0x68,
+       0x81, 0x9b, 0xf0, 0x52, 0xdd, 0x4d, 0xe8, 0xec,
+       0x2f, 0x21, 0xcf, 0x1e, 0x46, 0x8e, 0x11, 0xa6,
+       0xb0, 0xec, 0x6f, 0x2a, 0xd3, 0xa9, 0xea, 0xc6,
+       0x40, 0x13, 0xce, 0x24, 0x2d, 0xad, 0x6a, 0xbc,
+       0x68, 0x65, 0x33, 0xae, 0xa7, 0x1b, 0x03, 0x6d,
+       0x6a, 0xdc, 0xd3, 0x28, 0x35, 0xb4, 0x0d, 0xa3,
+       0xaf, 0x0f, 0xb6, 0x06, 0xda, 0x78, 0xbc, 0x72,
+       0x8a, 0x8b, 0x31, 0x2d, 0x92, 0xfc, 0x52, 0x7d,
+       0x53, 0x70, 0x25, 0x43, 0x66, 0xcc, 0x72, 0x93,
+       0x8b, 0xae, 0x8d, 0xdf, 0x69, 0xbb, 0x69, 0xfc,
+       0x4e, 0xcb, 0x2b, 0x52, 0x47, 0xf7, 0xb4, 0x97,
+       0x59, 0x3c, 0x4d, 0x82, 0x53, 0x2f, 0x74, 0xc0,
+       0x6a, 0x18, 0xb4, 0xcd, 0x75, 0xaf, 0x64, 0x02,
+       0xcd, 0xe9, 0x0c, 0x13, 0xa2, 0xd9, 0xa1, 0x6e,
+       0x73, 0x16, 0xc8, 0x95, 0xd6, 0x95, 0x10, 0x87,
+       0xfa, 0x64, 0xa6, 0xa7, 0xa9, 0xb4, 0xc3, 0xae,
+       0xdc, 0xcc, 0x47, 0xb0, 0xd7, 0x2e, 0x0f, 0x54,
+       0x77, 0x5a, 0x33, 0x60, 0x2a, 0xad, 0x8b, 0xd1,
+       0xca, 0x4d, 0x49, 0x2d, 0x2d, 0xba, 0x08, 0xa8,
+       0x81, 0xb6, 0xbb, 0x44, 0x3d, 0x7f, 0x86, 0xe3,
+       0xb6, 0x0d, 0xe1, 0xe6, 0x45, 0xdb, 0x5f, 0x28,
+       0x94, 0x4e, 0xca, 0x40, 0xbb, 0x9f, 0xa7, 0x59,
+       0x7b, 0xb2, 0xef, 0x21, 0xd8, 0xfb, 0x54, 0xb3,
+       0x3e, 0x3d, 0x66, 0xcb, 0x53, 0xa9, 0x26, 0x6e,
+       0xf5, 0x25, 0x68, 0xd8, 0xec, 0x0d, 0xc9, 0xf1,
+       0x64, 0xd3, 0x1b, 0x0f, 0x63, 0xc8, 0xe8, 0xfd,
+       0x96, 0x7c, 0x22, 0xd5, 0x44, 0x1e, 0x5e, 0xc3,
+       0xa4, 0xd4, 0x58, 0x06, 0x53, 0xb1, 0x0d, 0x59,
+       0x22, 0x5c, 0x40, 0xe8, 0xd2, 0xe3, 0x8c, 0x14,
+       0x52, 0x98, 0x35, 0xf7, 0x5c, 0x66, 0xd7, 0x1e,
+       0xb1, 0x20, 0x8d, 0x76, 0xd9, 0x5c, 0x66, 0x7b,
+       0x6d, 0x7a, 0x68, 0xaf, 0x96, 0xe7, 0x32, 0xbb,
+       0xf6, 0xd0, 0xb8, 0x78, 0x38, 0x03, 0x67, 0xa9,
+       0x2b, 0x64, 0x51, 0xca, 0x8f, 0xb3, 0xf8, 0x34,
+       0x8c, 0x7f, 0x28, 0xe0, 0x5c, 0x5b, 0x7e, 0x52,
+       0x84, 0x8f, 0x8f, 0xcd, 0x6e, 0x0f, 0xfa, 0xdb,
+       0x83, 0x9a, 0x7b, 0x26, 0x07, 0x5a, 0x97, 0xd1,
+       0x8c, 0x8a, 0xfe, 0x53, 0x1a, 0xcd, 0x25, 0xce,
+       0x8d, 0x32, 0x3c, 0xcc, 0xde, 0xfd, 0xf1, 0xf4,
+       0x62, 0xec, 0x69, 0x8c, 0x1d, 0x64, 0xb1, 0x6b,
+       0x1b, 0xa8, 0x84, 0xde, 0x56, 0x78, 0x78, 0x17,
+       0xe2, 0x9b, 0x11, 0xff, 0x2a, 0xc3, 0xf7, 0x49,
+       0xf0, 0xeb, 0x4c, 0x3f, 0x4c, 0x76, 0xea, 0x68,
+       0x87, 0x1a, 0x52, 0xd0, 0x13, 0x40, 0x4f, 0x1f,
+       0x3d, 0xc9, 0xf4, 0x5c, 0xf3, 0x47, 0x5e, 0x3f,
+       0xd2, 0x6c, 0xfe, 0xa1, 0x59, 0xe9, 0x13, 0xcc,
+       0xd5, 0xd8, 0x47, 0xbf, 0xae, 0x0d, 0x44, 0xba,
+       0xd6, 0x28, 0xcc, 0xde, 0x95, 0x7b, 0x45, 0x36,
+       0x8e, 0x1f, 0x3e, 0x80, 0xf5, 0x9b, 0x8e, 0x35,
+       0xcb, 0x2b, 0xf9, 0x06, 0xf9, 0x1e, 0xe8, 0x25,
+       0x4a, 0x6d, 0x59, 0x16, 0x48, 0xf7, 0x60, 0x39,
+       0x46, 0x39, 0x85, 0xcf, 0x67, 0x0f, 0x4f, 0x4f,
+       0x75, 0x4e, 0x78, 0x17, 0x79, 0x0e, 0x68, 0x23,
+       0x08, 0x7d, 0x32, 0x93, 0x50, 0x2e, 0xc2, 0xc4,
+       0x43, 0xe4, 0x31, 0xfc, 0x71, 0x3b, 0xca, 0x12,
+       0xa6, 0x5e, 0xa1, 0x1e, 0xb4, 0x9a, 0x69, 0x1d,
+       0xe4, 0x19, 0x90, 0x60, 0x02, 0xbd, 0x5b, 0xb4,
+       0xdd, 0x6a, 0x2a, 0x60, 0x76, 0x5a, 0xdd, 0x9d,
+       0x34, 0x10, 0x84, 0x3c, 0x86, 0x3d, 0xe1, 0xae,
+       0x59, 0xdb, 0xbd, 0x96, 0xaf, 0x48, 0xdc, 0xfb,
+       0x70, 0xae, 0xde, 0x8e, 0xe1, 0x78, 0x0c, 0x77,
+       0x89, 0x70, 0xfe, 0x65, 0x89, 0x39, 0x1a, 0x95,
+       0xdf, 0x90, 0x60, 0xc6, 0x6a, 0xe4, 0xfc, 0x26,
+       0x9b, 0x4f, 0x6d, 0xa9, 0x28, 0xa3, 0x19, 0x2d,
+       0x18, 0x7f, 0x8d, 0xc5, 0x13, 0x37, 0xac, 0x69,
+       0x85, 0xa9, 0xdb, 0x49, 0x7b, 0xca, 0x70, 0x55,
+       0x3d, 0xa3, 0x46, 0x82, 0x93, 0x63, 0xd5, 0x75,
+       0x83, 0x8d, 0x9e, 0x63, 0x96, 0xf5, 0xec, 0xec,
+       0x00, 0x83, 0x92, 0x84, 0x57, 0x9d, 0x62, 0xb6,
+       0x85, 0x5f, 0x7f, 0x77, 0x59, 0xbf, 0x18, 0xef,
+       0xe0, 0xd0, 0x24, 0x30, 0x88, 0x79, 0x9c, 0x58,
+       0x62, 0x9e, 0x99, 0x76, 0xa4, 0xff, 0xf4, 0xac,
+       0x8e, 0xc1, 0xed, 0x7f, 0x3f, 0x80, 0x38, 0x81,
+       0xed, 0xc4, 0xbb, 0x9c, 0x3b, 0x80, 0x55, 0xd9,
+       0xfe, 0xf7, 0xd8, 0x7f, 0xe7, 0xe3, 0xa3, 0x18,
+       0xe0, 0x98, 0xdf, 0x0c, 0x68, 0x18, 0xc3, 0x56,
+       0x15, 0x73, 0x49, 0x1b, 0x23, 0x53, 0x37, 0xd2,
+       0x98, 0x98, 0x8a, 0x96, 0x72, 0xfa, 0x5e, 0x19,
+       0x1e, 0xea, 0xc7, 0xdf, 0xf5, 0x0c, 0x6c, 0xc1,
+       0xf4, 0x57, 0x31, 0x74, 0x19, 0x7f, 0x3d, 0xe9,
+       0x90, 0x0a, 0x82, 0xf1, 0xf9, 0xa7, 0x5b, 0xe1,
+       0x21, 0xb4, 0x3f, 0xbf, 0xaa, 0x1b, 0xf4, 0xa0,
+       0x1e, 0x0f, 0xa2, 0x56, 0xc7, 0xa7, 0x19, 0x49,
+       0x53, 0xeb, 0xc7, 0xd2, 0x55, 0x5a, 0x8f, 0x14,
+       0xcf, 0x23, 0xff, 0xf5, 0x51, 0xfe, 0x39, 0xc4,
+       0xff, 0xa1, 0x2e, 0x6d, 0x0e, 0x55, 0x6c, 0x98,
+       0xda, 0x1c, 0x4d, 0x4d, 0x64, 0xa9, 0x1b, 0x9f,
+       0x3b, 0x9c, 0xba, 0x92, 0xdf, 0x17, 0xfd, 0xed,
+       0x92, 0xaf, 0xda, 0x0f, 0x5b, 0x25, 0x0e, 0xdd,
+       0x0f, 0x2b, 0xc1, 0x07, 0x27, 0x06, 0x6b, 0xf3,
+       0xd8, 0x05, 0xac, 0x0d, 0xe8, 0x5e, 0xd2, 0x46,
+       0x17, 0x5a, 0x61, 0x1c, 0x4d, 0x19, 0xfb, 0x5c,
+       0xbe, 0xea, 0x79, 0xe8, 0x51, 0x59, 0x97, 0xe3,
+       0xb8, 0xa9, 0x5b, 0x21, 0x83, 0x6e, 0x2d, 0xf3,
+       0xaf, 0xb6, 0xcf, 0x08, 0xd2, 0xf8, 0x03, 0x5c,
+       0xef, 0xd4, 0xd5, 0x21, 0xb6, 0x99, 0x63, 0xff,
+       0x6e, 0x80, 0xb0, 0x7a, 0xb2, 0x09, 0x15, 0x88,
+       0x9d, 0xc7, 0xb1, 0x5b, 0xd8, 0x58, 0x35, 0x12,
+       0x36, 0x1f, 0xb1, 0x4e, 0x8e, 0xfd, 0xfb, 0x81,
+       0xe5, 0x02, 0x62, 0xd2, 0x10, 0x93, 0xc5, 0x31,
+       0xde, 0xd3, 0xcb, 0x51, 0x6f, 0xeb, 0x12, 0x10,
+       0x93, 0x22, 0xcc, 0x14, 0xaa, 0xd0, 0xd7, 0xdb,
+       0xb6, 0xf1, 0x08, 0x58, 0xd1, 0x7e, 0x5c, 0x4f,
+       0x8d, 0x0d, 0x02, 0x72, 0xb1, 0x76, 0x23, 0x17,
+       0xa9, 0x17, 0x31, 0xfd, 0x24, 0x31, 0x11, 0xd7,
+       0x61, 0x2b, 0x93, 0x25, 0xb8, 0x13, 0x2d, 0xf9,
+       0x07, 0x8b, 0xd0, 0xfe, 0xdf, 0x81, 0x3a, 0x8d,
+       0x5e, 0xe1, 0x89, 0x24, 0x0c, 0xa3, 0x17, 0xef,
+       0xc4, 0xd9, 0xe2, 0x97, 0x57, 0xa2, 0xeb, 0xca,
+       0x43, 0x83, 0xed, 0x7d, 0xf4, 0x3a, 0xb5, 0x17,
+       0x76, 0x0d, 0x69, 0x67, 0x8e, 0xd6, 0x4e, 0x69,
+       0x03, 0xd2, 0x6e, 0x61, 0x75, 0xc2, 0xf2, 0xd2,
+       0x71, 0x64, 0x4b, 0xa8, 0xa1, 0xd0, 0x49, 0x25,
+       0x3e, 0x8e, 0xbe, 0xf5, 0x0a, 0x9c, 0xb7, 0xef,
+       0x5c, 0x8c, 0x9c, 0x2f, 0xa1, 0x3e, 0x1f, 0x45,
+       0xad, 0x3c, 0x2b, 0xc1, 0x2f, 0x5e, 0xc2, 0x30,
+       0x7a, 0xe2, 0x33, 0x4e, 0x20, 0xbe, 0x43, 0x2d,
+       0xb1, 0x66, 0x48, 0x79, 0xeb, 0xb0, 0xbc, 0xe2,
+       0x21, 0xa5, 0xe5, 0x46, 0x4b, 0x4b, 0x95, 0x33,
+       0x59, 0x59, 0x77, 0x6d, 0xa5, 0x16, 0x9a, 0x44,
+       0x6a, 0x61, 0xbc, 0x6c, 0x17, 0x6d, 0x6a, 0x9b,
+       0x05, 0xb2, 0x1b, 0xe2, 0x80, 0x6c, 0x62, 0xe5,
+       0xa3, 0xc4, 0x7f, 0x19, 0x10, 0xe1, 0x23, 0xb9,
+       0x0a, 0x17, 0x7c, 0x6d, 0x74, 0xe7, 0xb4, 0xad,
+       0x31, 0x10, 0x14, 0x1a, 0x9a, 0xda, 0x96, 0xe2,
+       0xa4, 0x41, 0xab, 0x3f, 0x3f, 0xbb, 0x29, 0x43,
+       0x37, 0x6c, 0x70, 0x99, 0x91, 0x35, 0x12, 0x6e,
+       0x43, 0x98, 0xf3, 0x75, 0x09, 0x73, 0x6f, 0x4b,
+       0xf8, 0xef, 0xd8, 0x9a, 0x3b, 0xb8, 0x02, 0x7c,
+       0xf0, 0x31, 0xd2, 0xda, 0xfc, 0xd3, 0x83, 0x5a,
+       0xdb, 0xb3, 0xeb, 0xab, 0xb4, 0x76, 0xd6, 0x2b,
+       0xc3, 0xb5, 0xf6, 0xc4, 0xd8, 0x41, 0xa9, 0x2e,
+       0x72, 0x50, 0x2f, 0xea, 0x0f, 0xde, 0x46, 0x6b,
+       0x8b, 0x34, 0xf9, 0x3e, 0x7e, 0x40, 0x06, 0xfd,
+       0xf6, 0x9b, 0xb5, 0xf6, 0x71, 0x1c, 0xa1, 0xfa,
+       0x67, 0x6e, 0xd6, 0xda, 0xc7, 0x9f, 0x47, 0xec,
+       0xf2, 0x9b, 0xb5, 0xf6, 0x71, 0xb4, 0x7c, 0x7a,
+       0x71, 0xa8, 0xd6, 0x3e, 0x8e, 0x16, 0x4a, 0x5f,
+       0x39, 0x54, 0x6b, 0x1f, 0x5f, 0x84, 0x98, 0xc2,
+       0xe1, 0x5a, 0xab, 0x3b, 0xa2, 0xf6, 0x20, 0x38,
+       0x89, 0x62, 0x2a, 0x52, 0x24, 0xbb, 0xfa, 0x9c,
+       0xe6, 0xef, 0xbd, 0x8b, 0x5e, 0xf0, 0xb8, 0x9f,
+       0xa2, 0x65, 0x2f, 0xcc, 0xc8, 0x84, 0x74, 0x13,
+       0xc6, 0x46, 0x4e, 0x5b, 0xb2, 0x3b, 0xb4, 0x4c,
+       0x9f, 0x0e, 0x2f, 0x3c, 0x45, 0x79, 0x90, 0x9a,
+       0xf2, 0x5f, 0xa6, 0x1e, 0x7f, 0x34, 0xe8, 0x5d,
+       0x87, 0x23, 0x33, 0x53, 0x82, 0xe5, 0x0e, 0x09,
+       0x12, 0x51, 0x02, 0xbf, 0x08, 0xb8, 0xfa, 0x6f,
+       0xdc, 0x8f, 0x33, 0x32, 0xea, 0xe0, 0xfb, 0x99,
+       0x18, 0x46, 0x1b, 0x3a, 0x6d, 0x11, 0xe2, 0xb5,
+       0x95, 0x22, 0xe8, 0x76, 0x0e, 0xca, 0xe8, 0x11,
+       0x2b, 0x1b, 0xd9, 0x5b, 0x07, 0x65, 0x53, 0x14,
+       0xd5, 0xf4, 0xc7, 0x5e, 0x46, 0xda, 0x75, 0xbc,
+       0x06, 0x4f, 0x0d, 0x0c, 0xd6, 0x20, 0x8d, 0xd5,
+       0x08, 0xd3, 0xd7, 0x61, 0xba, 0x4c, 0xb5, 0x58,
+       0x74, 0x05, 0x6b, 0x11, 0x90, 0xa0, 0xfd, 0x55,
+       0xac, 0x43, 0xb3, 0x04, 0xc7, 0xaf, 0xb8, 0xfa,
+       0xbf, 0xe8, 0xc6, 0x16, 0x9c, 0x97, 0xa0, 0x7b,
+       0x07, 0x86, 0x7f, 0x87, 0x61, 0xf4, 0x9e, 0x8e,
+       0x87, 0xa2, 0x75, 0xc8, 0x1a, 0xac, 0xc3, 0xc2,
+       0x4e, 0x56, 0x87, 0x21, 0xfd, 0x53, 0x14, 0xd5,
+       0xff, 0xc7, 0x52, 0x91, 0x56, 0x9f, 0x6e, 0x62,
+       0xa5, 0x26, 0xef, 0xc7, 0xbe, 0x79, 0xcc, 0x86,
+       0xa3, 0xad, 0x97, 0x95, 0xba, 0x02, 0x4b, 0x9c,
+       0x2a, 0xc1, 0x98, 0x7e, 0xee, 0x3f, 0x20, 0xff,
+       0xe5, 0x58, 0x96, 0x09, 0xcb, 0xc2, 0x3a, 0x74,
+       0x3b, 0x30, 0xdc, 0x8e, 0x61, 0x11, 0xf1, 0xe6,
+       0xe8, 0x28, 0xdf, 0x3d, 0xe8, 0x99, 0x2c, 0xb4,
+       0x61, 0xb9, 0xfb, 0x78, 0xa9, 0x54, 0x1a, 0xe7,
+       0x29, 0xbf, 0x64, 0xdd, 0x44, 0x1a, 0x22, 0xbf,
+       0xc0, 0xca, 0x04, 0xd3, 0xb3, 0xcb, 0xb1, 0x8e,
+       0x52, 0xe1, 0x73, 0x87, 0x8b, 0xfa, 0xa8, 0xa7,
+       0x1e, 0x5e, 0x3e, 0xb4, 0xdf, 0x16, 0x79, 0xc4,
+       0x45, 0x43, 0xe3, 0x8f, 0x06, 0x64, 0x1f, 0xf5,
+       0x62, 0x51, 0x1f, 0x7b, 0x9b, 0x8b, 0xf5, 0xe3,
+       0x54, 0x31, 0x1d, 0x26, 0x01, 0xef, 0xb9, 0x47,
+       0x7d, 0x72, 0x0e, 0xdd, 0xdf, 0x51, 0x79, 0xa1,
+       0xcf, 0x91, 0x16, 0x73, 0x62, 0x1f, 0xe5, 0x2d,
+       0x5e, 0xbb, 0x9c, 0x46, 0xf2, 0x89, 0xa1, 0xdc,
+       0x1e, 0xb9, 0x44, 0x75, 0x7a, 0x64, 0x03, 0xf6,
+       0xe4, 0x0b, 0x22, 0xfc, 0xdb, 0x06, 0x6d, 0x94,
+       0xe4, 0x15, 0xd0, 0x28, 0xc9, 0xdd, 0x8d, 0xf8,
+       0xac, 0xc1, 0xf6, 0x2c, 0x70, 0x92, 0x1c, 0x8d,
+       0x53, 0x79, 0x8b, 0x34, 0xad, 0xd7, 0x24, 0xf9,
+       0xc8, 0x8b, 0x32, 0x18, 0xc7, 0xb2, 0x9d, 0x26,
+       0xa9, 0xac, 0x85, 0xf3, 0x94, 0x64, 0x76, 0xcf,
+       0x88, 0xc7, 0x8a, 0xe8, 0xae, 0x3a, 0xbd, 0xb7,
+       0xf7, 0xb0, 0x43, 0x04, 0x43, 0xef, 0xcd, 0x23,
+       0xe2, 0x11, 0x51, 0x06, 0xc3, 0xd9, 0x9b, 0x47,
+       0xc4, 0x23, 0x5e, 0xc4, 0x1e, 0xe1, 0x6f, 0x29,
+       0x95, 0xb0, 0xfd, 0xd0, 0xae, 0x7e, 0xc3, 0x69,
+       0x7a, 0x63, 0xcc, 0x6b, 0x57, 0xf4, 0x79, 0xcf,
+       0xd5, 0x7c, 0xa7, 0x86, 0xdd, 0xcb, 0xc6, 0xfe,
+       0x39, 0xd3, 0xdb, 0x39, 0xf8, 0x9e, 0x2a, 0x83,
+       0xa1, 0x9b, 0x47, 0xd2, 0xc2, 0x01, 0xe4, 0xd6,
+       0x31, 0x74, 0x24, 0x2d, 0xbc, 0x84, 0x98, 0x25,
+       0xac, 0x05, 0x74, 0xf7, 0xfe, 0x34, 0xdb, 0x9f,
+       0x7c, 0x3a, 0xad, 0xe2, 0x36, 0x16, 0xc1, 0xaa,
+       0x59, 0x84, 0xb2, 0xcd, 0x39, 0x1b, 0x7d, 0xc5,
+       0xac, 0xe4, 0x9f, 0x45, 0x7a, 0xb8, 0x5d, 0x18,
+       0x3e, 0xf2, 0xf4, 0x5b, 0x99, 0x36, 0xa4, 0xd2,
+       0x8c, 0xc6, 0xfb, 0xd8, 0x69, 0x26, 0xd9, 0x3f,
+       0x5e, 0xab, 0xca, 0x9e, 0x69, 0xf7, 0xc2, 0x96,
+       0xcc, 0x02, 0x80, 0x25, 0xfa, 0xe2, 0x75, 0x55,
+       0xeb, 0x04, 0x97, 0x80, 0xde, 0xe5, 0x06, 0xec,
+       0xa7, 0xd2, 0xe7, 0x27, 0xc1, 0x0b, 0x21, 0x85,
+       0xcd, 0x53, 0x28, 0xf1, 0xeb, 0xa8, 0x67, 0x7a,
+       0x57, 0x7f, 0xff, 0x4f, 0x24, 0x78, 0x08, 0x7b,
+       0xfa, 0x67, 0xfb, 0x5c, 0xfd, 0x7f, 0xc2, 0x75,
+       0xd4, 0x43, 0x97, 0x25, 0xf8, 0xf9, 0x26, 0x4d,
+       0xe7, 0xf4, 0x3b, 0xb8, 0x7e, 0x0e, 0xf6, 0xd4,
+       0xfc, 0xe7, 0xb1, 0xa7, 0x0e, 0xf2, 0x7e, 0xd2,
+       0xfa, 0x67, 0xc1, 0x0d, 0xf9, 0x55, 0xea, 0x89,
+       0xa2, 0x1c, 0x99, 0x6a, 0x15, 0x93, 0xce, 0x46,
+       0x1d, 0xe2, 0x2f, 0xf0, 0xd2, 0x17, 0x84, 0xb0,
+       0xdc, 0xe6, 0x53, 0x21, 0x56, 0x2e, 0xae, 0xe6,
+       0x7e, 0xbe, 0x1e, 0xcb, 0x45, 0x3d, 0x7f, 0x08,
+       0x3d, 0xbb, 0x9f, 0x15, 0x63, 0xf8, 0x3b, 0x18,
+       0x0e, 0x22, 0x3e, 0x25, 0x5a, 0xae, 0xe3, 0x96,
+       0x72, 0xc7, 0xde, 0xa6, 0xdc, 0x75, 0x6a, 0xb9,
+       0xb9, 0x37, 0x95, 0xdb, 0xc2, 0x4a, 0x4a, 0x44,
+       0x8e, 0xb8, 0x22, 0xff, 0xbc, 0x0b, 0xb9, 0xa3,
+       0xa7, 0x76, 0xf4, 0x14, 0x96, 0x34, 0x0e, 0xc3,
+       0x16, 0x09, 0x8e, 0xed, 0x8c, 0x8e, 0xe6, 0x43,
+       0x37, 0x97, 0x34, 0x6f, 0xd7, 0x6d, 0x4a, 0x4a,
+       0xe1, 0x25, 0xe1, 0xd8, 0x7a, 0x69, 0xe8, 0xd8,
+       0x7a, 0xf4, 0xac, 0x36, 0xb6, 0x0a, 0x92, 0x87,
+       0x6a, 0x7f, 0xed, 0x65, 0x91, 0xd9, 0x97, 0xc1,
+       0xb9, 0xbd, 0xf6, 0x14, 0x96, 0xb5, 0x90, 0xea,
+       0x55, 0xdb, 0x81, 0xe5, 0x77, 0x62, 0xbd, 0x5c,
+       0x98, 0x0b, 0xa5, 0x71, 0xd4, 0x8d, 0xe1, 0x6f,
+       0x63, 0x18, 0xad, 0xd0, 0xb1, 0xe4, 0x41, 0x2b,
+       0x73, 0x4b, 0xbd, 0x52, 0x6e, 0xad, 0x57, 0xed,
+       0xd3, 0x6a, 0xbd, 0x72, 0xd4, 0x7a, 0xa9, 0xf3,
+       0x7a, 0x2d, 0xfa, 0xd9, 0xc0, 0xac, 0x6c, 0x6d,
+       0x3c, 0x71, 0x75, 0xf5, 0xf7, 0xa1, 0x5c, 0x0a,
+       0xd0, 0x9f, 0x7b, 0xef, 0x04, 0x96, 0x76, 0x17,
+       0x86, 0x31, 0xf7, 0xcf, 0x5e, 0x8d, 0xda, 0x96,
+       0xf0, 0xcd, 0xa5, 0xcd, 0x7d, 0xed, 0x36, 0xa5,
+       0x25, 0xa9, 0xa5, 0xe5, 0xaa, 0xa5, 0x0d, 0x99,
+       0xd9, 0xe7, 0xf7, 0xcb, 0xab, 0xc4, 0x80, 0xaa,
+       0x9d, 0x0b, 0x87, 0xea, 0xe6, 0xa2, 0x7d, 0x24,
+       0x07, 0x1a, 0x05, 0xf3, 0x3f, 0x90, 0xe7, 0xa5,
+       0x73, 0xcd, 0xa4, 0xd9, 0xc0, 0x3c, 0xc9, 0x80,
+       0xb8, 0x03, 0x83, 0x36, 0x25, 0xff, 0x83, 0xa8,
+       0x4d, 0xb1, 0x71, 0x9b, 0xb2, 0x28, 0x34, 0x54,
+       0xaa, 0xf3, 0x9f, 0x1f, 0xee, 0x3b, 0xcc, 0x5f,
+       0xc7, 0x7d, 0x87, 0xf9, 0xb8, 0xe2, 0xff, 0x59,
+       0xbe, 0x08, 0xbf, 0x9e, 0x54, 0xd9, 0x1a, 0x14,
+       0x24, 0xf5, 0x8e, 0xaf, 0xd0, 0x46, 0xb7, 0x82,
+       0xd9, 0x3d, 0xaf, 0xf1, 0x96, 0xdb, 0x3d, 0xed,
+       0x1b, 0xf6, 0x18, 0xef, 0xe6, 0x27, 0x7d, 0x43,
+       0xe0, 0x50, 0x3a, 0x06, 0x22, 0x7f, 0xfe, 0x61,
+       0xe1, 0x6d, 0x9e, 0x1e, 0x62, 0x3e, 0x96, 0xf5,
+       0xdf, 0xf7, 0x74, 0xf2, 0x2f, 0x7a, 0x7a, 0xc9,
+       0xab, 0x3d, 0x8c, 0x2f, 0xae, 0x95, 0x76, 0x8b,
+       0x70, 0x92, 0xee, 0xb6, 0xa0, 0x5f, 0x99, 0xcf,
+       0xf6, 0x12, 0x3b, 0xc7, 0x79, 0x6d, 0x8a, 0xd1,
+       0x6d, 0x13, 0xf5, 0x3e, 0xf4, 0xbf, 0x7f, 0x75,
+       0x79, 0xf6, 0xdc, 0x9a, 0x6a, 0xba, 0x6b, 0x41,
+       0xe2, 0xa2, 0x9d, 0x0e, 0x12, 0x3c, 0xf0, 0x21,
+       0xa7, 0xb3, 0xda, 0x70, 0x15, 0x32, 0x48, 0x79,
+       0x40, 0xbb, 0x0b, 0x5c, 0x87, 0x0b, 0xc2, 0x16,
+       0xba, 0xb7, 0xa4, 0x6e, 0xfb, 0xc3, 0xe5, 0x17,
+       0x7b, 0xa7, 0xa7, 0x2c, 0x57, 0x64, 0x6f, 0x82,
+       0x94, 0xe5, 0x4a, 0x90, 0x83, 0xde, 0xf5, 0xe4,
+       0x3d, 0x6c, 0xd5, 0x83, 0x76, 0x31, 0x67, 0x09,
+       0xc6, 0x5e, 0x61, 0xb1, 0x34, 0x5a, 0x19, 0x96,
+       0x09, 0xad, 0x30, 0x79, 0x8b, 0xfa, 0x6c, 0x45,
+       0xe0, 0x6b, 0xb6, 0xc9, 0xeb, 0xcd, 0x3a, 0x06,
+       0xd7, 0x6a, 0xeb, 0xa3, 0x9c, 0x3c, 0x8c, 0xd5,
+       0xe6, 0x12, 0xe7, 0x1e, 0x9a, 0x19, 0x5c, 0x4c,
+       0x2f, 0x25, 0x23, 0xd6, 0x25, 0x3f, 0x95, 0xca,
+       0x49, 0xdb, 0xc9, 0x78, 0xa1, 0x75, 0x5b, 0x9e,
+       0xce, 0xde, 0x95, 0x2a, 0xcb, 0x55, 0x8c, 0xbe,
+       0x50, 0xf5, 0x53, 0x6c, 0x2d, 0x95, 0x82, 0x1e,
+       0xf1, 0x31, 0x5a, 0x49, 0xc9, 0x32, 0xda, 0xdd,
+       0x7f, 0x8a, 0xa4, 0x2c, 0xf8, 0x2e, 0xad, 0x36,
+       0xcb, 0x04, 0x5a, 0x6d, 0x96, 0xa5, 0x65, 0x94,
+       0xb1, 0x15, 0xe2, 0xb9, 0xaf, 0xf3, 0x34, 0x25,
+       0xf1, 0xea, 0xee, 0x9a, 0x16, 0x6b, 0x57, 0xcd,
+       0x32, 0xb3, 0xf0, 0xee, 0xeb, 0xef, 0x35, 0x03,
+       0x9c, 0xa8, 0xf9, 0x4e, 0x74, 0x14, 0x1d, 0xfe,
+       0xe1, 0x91, 0x65, 0x3b, 0x45, 0x1c, 0x4d, 0xff,
+       0xe1, 0x52, 0x9e, 0xd9, 0xbd, 0xa9, 0xc5, 0xd2,
+       0xb5, 0x69, 0x99, 0x89, 0x95, 0xd2, 0x12, 0x2d,
+       0xa3, 0x01, 0x4b, 0xd8, 0x2d, 0x3e, 0xf6, 0x1f,
+       0xe6, 0x9f, 0xb9, 0x3b, 0x11, 0xf9, 0x27, 0xaa,
+       0xfc, 0xe3, 0x7d, 0x1a, 0x7f, 0x23, 0xf1, 0x17,
+       0xf6, 0x91, 0xe6, 0xb0, 0x77, 0x42, 0xb7, 0x95,
+       0xe3, 0x4a, 0x23, 0xf7, 0x24, 0x7b, 0x4b, 0x14,
+       0x7b, 0xef, 0xe1, 0x3d, 0x0c, 0x37, 0x17, 0x71,
+       0x07, 0x85, 0x38, 0x2a, 0x8f, 0x63, 0x2b, 0xdb,
+       0xab, 0xeb, 0xa5, 0x16, 0x21, 0x40, 0x0f, 0xdf,
+       0xf8, 0x9d, 0xf6, 0xc9, 0x78, 0x91, 0xc0, 0xd1,
+       0x21, 0xc3, 0xfd, 0x5b, 0xb3, 0x20, 0x3d, 0x36,
+       0x23, 0x36, 0xda, 0x2b, 0x4f, 0x55, 0x3f, 0x5d,
+       0xc4, 0x3d, 0x97, 0xb2, 0x60, 0x84, 0xf7, 0xcf,
+       0x12, 0x7a, 0x2e, 0x8e, 0xeb, 0x9b, 0xdc, 0x16,
+       0x11, 0x7e, 0xd9, 0x80, 0xbd, 0x75, 0x90, 0xf5,
+       0xd6, 0x63, 0x81, 0xa8, 0xf7, 0xa3, 0xb3, 0xee,
+       0x7a, 0x0e, 0x7b, 0xd7, 0x94, 0xb1, 0xe0, 0xeb,
+       0xb4, 0x6f, 0x4c, 0xc5, 0x9e, 0x9a, 0x96, 0x83,
+       0xbb, 0x6b, 0x96, 0x85, 0x85, 0x89, 0x91, 0x81,
+       0x34, 0xf6, 0x96, 0x51, 0xd9, 0x44, 0xac, 0xe9,
+       0x0a, 0x16, 0xca, 0xc0, 0x92, 0x8c, 0xe2, 0x4b,
+       0x83, 0xdc, 0xe1, 0x35, 0xe2, 0x0e, 0x3b, 0xbe,
+       0x1e, 0xf7, 0x84, 0x2b, 0x7b, 0x36, 0x21, 0xf7,
+       0x4d, 0xb7, 0x70, 0x4f, 0xd6, 0xb8, 0xe7, 0xbc,
+       0x3c, 0x84, 0x7b, 0x15, 0xf2, 0xae, 0xf8, 0x9a,
+       0x9c, 0x37, 0xed, 0x49, 0x6c, 0x39, 0xbc, 0x3b,
+       0x71, 0xd9, 0xc1, 0xe1, 0x9c, 0xa7, 0x86, 0xa3,
+       0x9c, 0x2b, 0xc4, 0x1d, 0x69, 0x6b, 0x7f, 0x34,
+       0x80, 0xfd, 0x6f, 0x6f, 0x36, 0x0b, 0x5e, 0x01,
+       0xed, 0xdf, 0xc0, 0x8d, 0x9b, 0x9f, 0xd5, 0xe5,
+       0xa4, 0x8b, 0x70, 0x22, 0x85, 0xdf, 0xea, 0x6d,
+       0xc7, 0xa5, 0x4f, 0x4d, 0x75, 0x74, 0x63, 0xee,
+       0x78, 0x7a, 0xca, 0xf9, 0xce, 0x4e, 0x7a, 0xa7,
+       0xa0, 0xac, 0x42, 0x09, 0xf0, 0x67, 0xb2, 0x13,
+       0x7a, 0xc0, 0x8c, 0xf1, 0x3c, 0x84, 0x56, 0x84,
+       0x05, 0x08, 0x6d, 0x08, 0x0b, 0x11, 0x26, 0x22,
+       0x74, 0x22, 0xcc, 0x40, 0x58, 0x8c, 0x30, 0x13,
+       0xa1, 0xa7, 0xa8, 0x1f, 0xce, 0x8e, 0x2f, 0x03,
+       0x33, 0xc2, 0xf3, 0x08, 0xad, 0x08, 0x7b, 0x10,
+       0xda, 0x10, 0x5e, 0x46, 0x98, 0x88, 0xb0, 0x17,
+       0x61, 0x06, 0xc2, 0x6b, 0x08, 0x33, 0xa9, 0x5e,
+       0xb3, 0xae, 0x49, 0x90, 0xfd, 0xac, 0xd8, 0xc1,
+       0x4b, 0xc4, 0x94, 0x17, 0x7f, 0x88, 0xa5, 0xca,
+       0x66, 0xf6, 0x3c, 0x38, 0x8f, 0xf1, 0xda, 0x8c,
+       0x18, 0xab, 0x8a, 0x29, 0x60, 0x5c, 0x37, 0x22,
+       0xc6, 0xa6, 0x62, 0x0a, 0x19, 0xff, 0x67, 0x10,
+       0x93, 0xa8, 0x62, 0x9c, 0xac, 0xa4, 0x75, 0x88,
+       0xc9, 0x50, 0x31, 0xc5, 0xac, 0xcc, 0x10, 0x62,
+       0x32, 0x55, 0x8c, 0x87, 0x97, 0x5e, 0x89, 0xd2,
+       0xcd, 0xc6, 0xf9, 0xef, 0x9d, 0x78, 0x11, 0x7e,
+       0xa1, 0x2f, 0x6e, 0xac, 0x6b, 0x57, 0xb4, 0xcd,
+       0x59, 0x68, 0xb4, 0x86, 0xc6, 0x65, 0x99, 0xac,
+       0xd8, 0x18, 0xfe, 0x6e, 0xe7, 0x04, 0x11, 0x7e,
+       0xf2, 0x12, 0x86, 0xf5, 0x6a, 0x78, 0x33, 0x7b,
+       0x97, 0x9c, 0x87, 0x9f, 0x19, 0x43, 0x3d, 0xca,
+       0xc3, 0xb4, 0xdb, 0x28, 0x46, 0x0d, 0x07, 0x31,
+       0x6c, 0x52, 0xc3, 0x8b, 0xe9, 0x2d, 0x0e, 0xf5,
+       0xfd, 0xdb, 0x09, 0x8a, 0xed, 0x63, 0x8f, 0xf0,
+       0x4d, 0x48, 0xc0, 0x71, 0xb1, 0x8e, 0x79, 0xb3,
+       0x13, 0xe8, 0x9d, 0x0d, 0xf5, 0x74, 0xaf, 0x6d,
+       0x95, 0x2f, 0xe2, 0xef, 0x47, 0xf8, 0x3b, 0x8e,
+       0xbf, 0x3f, 0xc0, 0xb6, 0xd9, 0xa3, 0xf1, 0x97,
+       0x3d, 0x58, 0xb3, 0xa9, 0x82, 0xbb, 0xbd, 0x4d,
+       0x68, 0x0c, 0x04, 0x5a, 0x03, 0x43, 0x2b, 0x3c,
+       0x55, 0xd0, 0x8c, 0xb1, 0xc4, 0xb7, 0x2d, 0xdc,
+       0x3e, 0x91, 0x9e, 0x86, 0x06, 0xda, 0xeb, 0x83,
+       0x4d, 0xad, 0x2d, 0xc3, 0x09, 0x8a, 0x9b, 0x96,
+       0x37, 0xb5, 0x21, 0x96, 0xce, 0xfe, 0x59, 0xd5,
+       0x18, 0x68, 0x1d, 0x9e, 0x5a, 0xd1, 0xd4, 0xd2,
+       0x38, 0xd9, 0xf5, 0xe5, 0xb9, 0x59, 0x7a, 0xe9,
+       0xf0, 0x74, 0xd0, 0xde, 0x25, 0x2e, 0x8d, 0xc3,
+       0x31, 0x75, 0x8e, 0xef, 0x4e, 0x97, 0x60, 0x31,
+       0xdf, 0x5f, 0x6e, 0x51, 0x2c, 0x7c, 0xa7, 0x3a,
+       0xae, 0xed, 0x9a, 0xe9, 0x24, 0xb9, 0xdd, 0x89,
+       0x74, 0xfd, 0x97, 0xc5, 0xec, 0xba, 0x83, 0xf4,
+       0x5c, 0xc9, 0x0a, 0x44, 0x84, 0xfd, 0xf4, 0x8f,
+       0xce, 0xa8, 0x53, 0x32, 0xe9, 0x5e, 0x5c, 0xb9,
+       0x19, 0x79, 0x3d, 0x3f, 0x78, 0xb7, 0xf5, 0x8e,
+       0xef, 0x56, 0x3b, 0x11, 0xc3, 0x9e, 0x62, 0xdf,
+       0xb1, 0x0d, 0xc3, 0x41, 0x16, 0xda, 0x8d, 0xa1,
+       0x25, 0x2c, 0x74, 0x0c, 0x43, 0x22, 0x0b, 0x9d,
+       0xc3, 0xd0, 0x3c, 0xb6, 0x03, 0xfe, 0x3c, 0x86,
+       0x2a, 0x58, 0xa8, 0x1b, 0x43, 0x6e, 0x16, 0xda,
+       0x8f, 0x21, 0xf6, 0x26, 0x71, 0xd2, 0x0e, 0x0c,
+       0x65, 0xb1, 0xd0, 0x46, 0x0c, 0xa5, 0xb1, 0x50,
+       0x08, 0x43, 0x6c, 0x54, 0x27, 0x39, 0x31, 0x64,
+       0x63, 0xa1, 0x4c, 0x0c, 0xb1, 0xf9, 0x33, 0x69,
+       0x8c, 0x04, 0x59, 0xfb, 0xf8, 0x1b, 0xbf, 0x12,
+       0xdc, 0xbf, 0x41, 0x86, 0xf4, 0x6e, 0xc1, 0x89,
+       0xb8, 0x1d, 0x22, 0x74, 0xbf, 0x88, 0x98, 0xd5,
+       0x88, 0x79, 0x53, 0xdb, 0x4b, 0x70, 0xbf, 0x1f,
+       0x63, 0x5d, 0xb7, 0xee, 0x25, 0x48, 0x7f, 0x81,
+       0xef, 0x25, 0x08, 0x80, 0x36, 0xdb, 0xdd, 0x5f,
+       0xba, 0x14, 0xd2, 0x97, 0xb4, 0xb0, 0x77, 0x87,
+       0xca, 0x7a, 0xf2, 0xf5, 0x3e, 0xd7, 0x98, 0x90,
+       0x00, 0x67, 0x3b, 0xe7, 0x1c, 0x89, 0x5c, 0xf7,
+       0x15, 0x1d, 0x7f, 0xeb, 0x87, 0x03, 0x88, 0xdf,
+       0xb1, 0xac, 0xbb, 0xda, 0x85, 0x74, 0x6e, 0x6d,
+       0xb7, 0xc1, 0x0f, 0x0f, 0x23, 0xaf, 0x2a, 0xbe,
+       0xc3, 0xc0, 0xc6, 0x77, 0x18, 0x2c, 0x57, 0x2d,
+       0x50, 0x33, 0x3d, 0x6f, 0xf7, 0x9c, 0xfb, 0x7a,
+       0xfb, 0x05, 0xe2, 0x6d, 0xbe, 0xce, 0xae, 0x14,
+       0xf9, 0xcd, 0x3c, 0x5d, 0xba, 0x57, 0x34, 0x25,
+       0xdd, 0xbd, 0x3b, 0x45, 0xde, 0x89, 0x25, 0xf7,
+       0xd1, 0x9e, 0x0c, 0xba, 0x1b, 0x7b, 0xbb, 0x7d,
+       0x03, 0xf9, 0x38, 0x0b, 0x4c, 0xde, 0x49, 0x3b,
+       0x32, 0xc4, 0x75, 0x37, 0xdb, 0xa2, 0xc9, 0x5b,
+       0x44, 0xf8, 0xf9, 0x06, 0xb2, 0x3a, 0x93, 0x5a,
+       0x64, 0xb8, 0xf7, 0xb5, 0x70, 0x47, 0xe4, 0x86,
+       0x26, 0x93, 0x49, 0x8b, 0x10, 0xf3, 0x42, 0x14,
+       0x33, 0x4c, 0x2e, 0xf7, 0x3e, 0xad, 0xed, 0xb1,
+       0x48, 0x37, 0xd2, 0x9a, 0xf1, 0x5e, 0xf6, 0x84,
+       0xaf, 0xac, 0x16, 0x7d, 0x91, 0x49, 0xb2, 0x99,
+       0xde, 0xd9, 0x97, 0xfb, 0xc5, 0xcb, 0x36, 0x1b,
+       0xed, 0xbb, 0xb8, 0xf7, 0x4d, 0xdb, 0x90, 0x7d,
+       0x17, 0x24, 0x89, 0x7b, 0x4b, 0xb3, 0xe2, 0xf8,
+       0x9a, 0x33, 0x33, 0x8e, 0xf3, 0x99, 0x14, 0xb7,
+       0xc2, 0xf2, 0xfa, 0x3b, 0x28, 0x95, 0xf5, 0x51,
+       0xab, 0x1f, 0xe2, 0x72, 0x99, 0x62, 0xa6, 0x7d,
+       0x74, 0x23, 0xed, 0x42, 0xa9, 0x1f, 0xdb, 0xbf,
+       0x3a, 0x28, 0x94, 0xd8, 0xec, 0xa9, 0xa5, 0x09,
+       0x77, 0xed, 0x34, 0x2a, 0x35, 0x3b, 0x41, 0xbe,
+       0x9e, 0xe6, 0x49, 0x2f, 0x4b, 0x4c, 0x56, 0x12,
+       0x12, 0xee, 0x46, 0x4c, 0xcf, 0xae, 0x42, 0x98,
+       0xa4, 0xf4, 0xee, 0xd4, 0x2b, 0x97, 0xc5, 0xd3,
+       0x19, 0xf3, 0xbf, 0x8e, 0x44, 0xad, 0x6f, 0x22,
+       0x67, 0xb4, 0xd3, 0xab, 0x93, 0x05, 0x9c, 0x4d,
+       0x33, 0xd7, 0x0b, 0x8f, 0xd7, 0x74, 0x8a, 0x10,
+       0x09, 0x8a, 0x70, 0x6c, 0x85, 0x04, 0x13, 0x6b,
+       0x65, 0x48, 0xdb, 0xac, 0x49, 0x64, 0x22, 0xae,
+       0x4b, 0xd3, 0xd6, 0x0f, 0x97, 0x86, 0x26, 0x87,
+       0xb4, 0x01, 0x92, 0x43, 0x5a, 0x27, 0x97, 0x03,
+       0x6f, 0x79, 0xda, 0xce, 0x9b, 0x5b, 0x9e, 0x56,
+       0xa1, 0xb6, 0xfc, 0xf4, 0x2d, 0x2d, 0xdf, 0x10,
+       0x6d, 0xf9, 0xba, 0xc1, 0x96, 0x7f, 0x9d, 0x16,
+       0x8c, 0x18, 0xa0, 0x9a, 0xdf, 0xb9, 0x6f, 0x88,
+       0x64, 0xa6, 0x0e, 0x91, 0x8c, 0x95, 0x4b, 0x06,
+       0x65, 0x72, 0x55, 0x3c, 0x27, 0xdc, 0xc9, 0x4f,
+       0x93, 0x98, 0x79, 0x7c, 0x34, 0xbd, 0x77, 0x1c,
+       0x67, 0x1b, 0xa0, 0x5d, 0xaa, 0xb9, 0x37, 0x5c,
+       0xea, 0x1d, 0x80, 0xfb, 0xb1, 0xfd, 0x3e, 0x6a,
+       0x3f, 0xce, 0xf5, 0x3f, 0xc3, 0xf6, 0x67, 0xd4,
+       0x2e, 0x85, 0x09, 0x1d, 0x8a, 0xc5, 0x0f, 0xfc,
+       0xed, 0xdd, 0xf9, 0xce, 0x80, 0xae, 0x6b, 0x4d,
+       0x0b, 0x4c, 0x58, 0xec, 0x0d, 0x61, 0x4a, 0x9d,
+       0x8b, 0xad, 0x94, 0xbd, 0x0e, 0x00, 0x05, 0x26,
+       0xd4, 0xcc, 0x73, 0xd2, 0x89, 0x89, 0x48, 0x05,
+       0x6c, 0x6c, 0xe3, 0xaa, 0xf1, 0xfe, 0xa9, 0xf4,
+       0xfc, 0x2f, 0x37, 0x0f, 0xb9, 0x4d, 0xd2, 0x76,
+       0x92, 0xfc, 0x4c, 0x18, 0x7c, 0x27, 0xdf, 0x79,
+       0x27, 0xc6, 0x6d, 0x34, 0x42, 0xef, 0xbb, 0x82,
+       0xfc, 0xb2, 0x64, 0x7e, 0x7e, 0xd3, 0x6e, 0x8d,
+       0xf6, 0xe8, 0x35, 0xed, 0xde, 0xc4, 0x84, 0x17,
+       0x48, 0xbe, 0x13, 0xd0, 0x3f, 0xbe, 0xef, 0xa0,
+       0x0c, 0x13, 0x8c, 0x54, 0x7e, 0xea, 0x0d, 0xba,
+       0xef, 0x1d, 0x5e, 0x3b, 0xb8, 0x32, 0xf2, 0x6c,
+       0xc2, 0x95, 0x51, 0x4a, 0x9a, 0x31, 0x75, 0x66,
+       0xfa, 0x44, 0x74, 0xa4, 0x0c, 0xa9, 0x86, 0xe3,
+       0x6b, 0x05, 0x3d, 0xad, 0x43, 0xbc, 0xd7, 0xd9,
+       0xf5, 0x05, 0xa4, 0xdf, 0xc1, 0x9e, 0x38, 0x9a,
+       0x65, 0xf6, 0x36, 0x4f, 0x62, 0x03, 0x6a, 0xfa,
+       0xa6, 0x80, 0x59, 0x30, 0xe1, 0xcc, 0xfc, 0x0c,
+       0x96, 0xb8, 0x36, 0x5a, 0xe2, 0x24, 0x2c, 0xd1,
+       0xa2, 0xdd, 0x05, 0x9f, 0xb3, 0x93, 0xcb, 0xc8,
+       0x6d, 0x4b, 0xc5, 0x9e, 0xf5, 0x9d, 0xc0, 0xf2,
+       0xcd, 0xe9, 0x2e, 0x7a, 0x02, 0xe3, 0x43, 0x4f,
+       0xf7, 0x68, 0x85, 0x96, 0x2b, 0xf5, 0x5a, 0x07,
+       0x68, 0x79, 0x7c, 0xaf, 0x51, 0x2d, 0x61, 0xcb,
+       0x14, 0xe0, 0x94, 0x73, 0x4e, 0x09, 0xe3, 0xbc,
+       0x21, 0x3a, 0x0f, 0xc1, 0xb7, 0x2e, 0xd5, 0xc9,
+       0x9f, 0x4b, 0xd9, 0x70, 0xbd, 0x94, 0xe6, 0x09,
+       0x8e, 0x4d, 0x0c, 0xd3, 0x7b, 0x87, 0xee, 0x84,
+       0x12, 0xfe, 0x4c, 0x2a, 0x59, 0xd4, 0xdb, 0x4e,
+       0xb1, 0xe7, 0xd0, 0xea, 0x93, 0xb0, 0x89, 0xbd,
+       0xde, 0x89, 0x30, 0x4d, 0xb1, 0xd2, 0xc8, 0x9d,
+       0xeb, 0xc7, 0xf8, 0x59, 0xd1, 0x22, 0x60, 0x1b,
+       0x03, 0xd8, 0xaa, 0xec, 0x5e, 0x86, 0x5d, 0x89,
+       0xd8, 0x23, 0x82, 0x7a, 0xa6, 0xc9, 0x23, 0xae,
+       0xe3, 0xae, 0xd0, 0x7e, 0x8f, 0xd3, 0xeb, 0xa4,
+       0x77, 0xcf, 0xff, 0xf7, 0x2a, 0x55, 0xbb, 0xac,
+       0xa9, 0xb4, 0xc3, 0x31, 0xc9, 0x1b, 0x6a, 0x81,
+       0x48, 0xc7, 0xb9, 0x67, 0x1b, 0xa2, 0x96, 0x60,
+       0xe2, 0x06, 0x11, 0xde, 0x5b, 0x27, 0x08, 0x42,
+       0x46, 0x71, 0x99, 0x6f, 0x22, 0x5f, 0xc3, 0xa5,
+       0x2f, 0x94, 0x61, 0xfc, 0x16, 0xc1, 0x99, 0xea,
+       0x71, 0x7f, 0x1f, 0x8c, 0x7e, 0xc8, 0x29, 0x84,
+       0x48, 0xf7, 0xe6, 0x06, 0xbd, 0x2f, 0x44, 0x6f,
+       0x5d, 0x97, 0x86, 0x26, 0x38, 0x01, 0xdb, 0xfe,
+       0x5e, 0x15, 0xb6, 0xc1, 0x27, 0xd2, 0xd9, 0x1b,
+       0xf3, 0xe9, 0xd4, 0x8d, 0xb2, 0x5d, 0x98, 0x53,
+       0xc0, 0x9c, 0x22, 0x1b, 0x29, 0xaf, 0x62, 0x2c,
+       0x01, 0x63, 0xf9, 0x24, 0x8b, 0xf1, 0x0e, 0x7a,
+       0xa2, 0x6f, 0x3a, 0xd3, 0x02, 0xe3, 0xd3, 0x49,
+       0x57, 0xca, 0xba, 0xe8, 0xd9, 0xcb, 0xbd, 0x57,
+       0x31, 0x3d, 0x89, 0xa5, 0xdb, 0x18, 0x76, 0xe7,
+       0xf1, 0xd0, 0x4e, 0xa2, 0x3b, 0xdb, 0x02, 0xc2,
+       0x0d, 0xe6, 0xdf, 0xbe, 0xca, 0x7c, 0xd1, 0x9d,
+       0x07, 0x06, 0xf4, 0x70, 0x1c, 0xa5, 0xf1, 0xe6,
+       0xb3, 0x52, 0x96, 0x9c, 0x46, 0xde, 0x4a, 0xd9,
+       0xab, 0xfc, 0xcc, 0x88, 0xb2, 0x2e, 0xeb, 0x43,
+       0x30, 0x9f, 0x4a, 0x97, 0xb1, 0x7f, 0xf2, 0x1a,
+       0xa4, 0xa9, 0xf4, 0x66, 0x65, 0xde, 0x5a, 0xa4,
+       0xdd, 0x23, 0xc2, 0x91, 0x57, 0x71, 0xae, 0xb7,
+       0xd1, 0x7d, 0x9d, 0x72, 0x81, 0x9f, 0x05, 0xe4,
+       0xed, 0x55, 0x4c, 0x2c, 0xbe, 0x9c, 0x76, 0x3a,
+       0x4f, 0xbb, 0xc6, 0x75, 0xa2, 0xe2, 0x8c, 0x99,
+       0x9f, 0x91, 0xe3, 0xb8, 0x89, 0xd6, 0xc6, 0xcf,
+       0x13, 0xf2, 0xf6, 0xca, 0xc9, 0x3c, 0x57, 0xda,
+       0x52, 0xb0, 0xba, 0x7f, 0x00, 0x09, 0x7e, 0x5d,
+       0xe5, 0x2b, 0x60, 0xe3, 0x73, 0x65, 0xc5, 0x19,
+       0x2b, 0xe6, 0xee, 0x80, 0xe9, 0xb4, 0x2f, 0x85,
+       0xcd, 0x42, 0x2f, 0xa6, 0xd0, 0x7e, 0x4c, 0x55,
+       0xdf, 0xec, 0x6a, 0x1f, 0xd8, 0x4e, 0x77, 0xc0,
+       0x88, 0x39, 0x3f, 0x8f, 0x7c, 0x88, 0xeb, 0x38,
+       0x2b, 0x8e, 0xb1, 0x24, 0xe9, 0x59, 0xac, 0xa1,
+       0x45, 0x7d, 0x5e, 0xcf, 0x6e, 0x81, 0x37, 0xb5,
+       0x09, 0xb3, 0xcb, 0xd1, 0xd5, 0x29, 0x6d, 0x0d,
+       0x2c, 0x93, 0xd4, 0xdb, 0xe2, 0x4d, 0x2d, 0x42,
+       0x03, 0x7b, 0x4c, 0x0b, 0x7c, 0x2b, 0x94, 0x30,
+       0x63, 0xf0, 0xfe, 0xb6, 0xb0, 0x9a, 0xfa, 0x71,
+       0x3e, 0xb6, 0xe4, 0xbe, 0xc3, 0x83, 0x23, 0x55,
+       0x82, 0x29, 0x1f, 0x30, 0x7c, 0x12, 0xe2, 0xbb,
+       0x24, 0xf4, 0x7e, 0x5c, 0xfd, 0x3d, 0x6f, 0x60,
+       0xf8, 0x25, 0xb6, 0x2b, 0x6c, 0xb9, 0x04, 0x37,
+       0x2e, 0xc9, 0x7e, 0x3a, 0x29, 0x8a, 0xef, 0x0c,
+       0x5b, 0x1d, 0xc1, 0xb1, 0x1a, 0xd0, 0x9e, 0x23,
+       0x50, 0xfd, 0x73, 0xfd, 0x45, 0xec, 0xc9, 0xb8,
+       0x7f, 0x1c, 0x9d, 0x52, 0xa4, 0x9e, 0x54, 0x74,
+       0x9d, 0x97, 0x8a, 0xa3, 0x03, 0xb5, 0x89, 0x76,
+       0x3d, 0xff, 0x30, 0x2c, 0x41, 0x8d, 0x5b, 0x7b,
+       0x7e, 0x3f, 0xbf, 0xd2, 0x51, 0x68, 0x40, 0x0d,
+       0xcd, 0xa6, 0x3a, 0x6d, 0x7f, 0xc0, 0x8f, 0xb1,
+       0x6f, 0x60, 0x8c, 0x30, 0xc7, 0xb0, 0xc4, 0x97,
+       0x44, 0x78, 0x77, 0xac, 0x56, 0xef, 0x71, 0x87,
+       0xa2, 0xf5, 0xb6, 0x0d, 0xab, 0xf7, 0x58, 0xad,
+       0xde, 0xe9, 0x7d, 0x12, 0xec, 0xdd, 0x87, 0xf5,
+       0x46, 0x6c, 0xfa, 0x65, 0x56, 0xef, 0x55, 0xc8,
+       0x25, 0x47, 0x0e, 0xfe, 0x65, 0xf5, 0xab, 0xde,
+       0xae, 0xd5, 0x6f, 0xde, 0x6b, 0xbc, 0x7e, 0x8e,
+       0x0f, 0x87, 0xd6, 0xcf, 0xd1, 0xcd, 0xd3, 0x53,
+       0x3d, 0xfe, 0x27, 0xdd, 0x7f, 0x4f, 0x23, 0x4f,
+       0xd8, 0x57, 0x3c, 0xbb, 0x5a, 0x47, 0xda, 0xe1,
+       0x40, 0x8d, 0xce, 0x46, 0xcf, 0xf0, 0x8b, 0x1e,
+       0x11, 0x0e, 0xd7, 0xa1, 0x65, 0x70, 0xcb, 0x30,
+       0xf6, 0x55, 0x75, 0x37, 0x19, 0xed, 0x97, 0x41,
+       0x8d, 0xcb, 0xda, 0x5b, 0xd5, 0xd9, 0x21, 0xd8,
+       0x0e, 0x05, 0xd0, 0x77, 0xca, 0xfa, 0xc0, 0x76,
+       0x08, 0xf1, 0xa9, 0x01, 0xd6, 0x3f, 0xa3, 0x0f,
+       0x7f, 0xb4, 0x39, 0x01, 0x6c, 0x9f, 0xda, 0xe0,
+       0xcb, 0x20, 0xd1, 0xb2, 0x1c, 0xf7, 0x06, 0x0d,
+       0x81, 0xd8, 0xf7, 0x43, 0x0d, 0x26, 0x0c, 0x67,
+       0x8b, 0xf4, 0x94, 0xda, 0x81, 0x23, 0xad, 0x17,
+       0x61, 0x16, 0x5a, 0x87, 0x0b, 0xd5, 0x9d, 0x18,
+       0xb2, 0xb8, 0xed, 0x9a, 0xb5, 0xbe, 0xf7, 0xb4,
+       0x08, 0xef, 0x1c, 0xf7, 0x7c, 0x72, 0x76, 0xe8,
+       0x79, 0x11, 0x05, 0x83, 0xe7, 0x45, 0x68, 0x27,
+       0x3d, 0xf0, 0x73, 0x23, 0x7e, 0x32, 0x10, 0x88,
+       0x4d, 0xcc, 0x02, 0xd3, 0xae, 0x5b, 0x4e, 0x7c,
+       0xa0, 0x51, 0xeb, 0x3d, 0x51, 0x71, 0x06, 0x62,
+       0x2b, 0xdb, 0x6d, 0x76, 0xb4, 0x4f, 0x2f, 0xb3,
+       0xf7, 0x2e, 0xae, 0x55, 0x77, 0x92, 0x15, 0x9c,
+       0x0a, 0x4b, 0xe1, 0x9e, 0x75, 0x84, 0xbf, 0x27,
+       0x30, 0x88, 0x4f, 0x9d, 0x2e, 0xc3, 0x3d, 0x75,
+       0x7b, 0x3b, 0xc0, 0xb6, 0x6c, 0x89, 0xcc, 0x4f,
+       0x97, 0xdb, 0x2d, 0x36, 0x63, 0x7c, 0x8c, 0x6a,
+       0xc3, 0xdf, 0xc4, 0x70, 0xa2, 0x1a, 0xde, 0x8b,
+       0xe1, 0xd1, 0xb2, 0x99, 0x9d, 0xa7, 0xbb, 0x4b,
+       0x2c, 0xc5, 0x58, 0x82, 0x9a, 0xe7, 0x80, 0x58,
+       0x80, 0xb1, 0x3b, 0xd4, 0xd8, 0x21, 0x71, 0x12,
+       0xc6, 0x92, 0xd4, 0xd8, 0x71, 0x31, 0x05, 0x63,
+       0x77, 0xaa, 0xb1, 0x23, 0x62, 0xbc, 0x48, 0xd6,
+       0x6f, 0xfb, 0x8c, 0xe0, 0xc7, 0xb3, 0xc6, 0x87,
+       0xaa, 0x80, 0xee, 0x30, 0x1c, 0x3a, 0x81, 0x9e,
+       0xcf, 0xe1, 0x80, 0x99, 0xbd, 0x19, 0x1e, 0x14,
+       0xee, 0xa2, 0xf4, 0x52, 0xf4, 0xfc, 0x26, 0x67,
+       0xaa, 0x61, 0x1c, 0x7f, 0x93, 0x05, 0x35, 0x7c,
+       0x2f, 0x86, 0x13, 0xd5, 0x70, 0x16, 0x86, 0xcd,
+       0x6a, 0xf8, 0x41, 0x9c, 0xf7, 0x07, 0xd4, 0x30,
+       0x7a, 0x88, 0x99, 0xbd, 0x6a, 0xb8, 0x0c, 0xc3,
+       0xe7, 0xd5, 0x30, 0xae, 0x7f, 0x33, 0x4f, 0xaa,
+       0xe1, 0xc7, 0x30, 0x7c, 0x54, 0x0d, 0x2b, 0x18,
+       0x0e, 0xab, 0x61, 0xd4, 0xa9, 0xcc, 0x5d, 0x6a,
+       0x18, 0x6d, 0x71, 0xe6, 0x0e, 0x35, 0x8c, 0x36,
+       0x28, 0xf3, 0x05, 0x35, 0xfc, 0x5d, 0x0c, 0x6f,
+       0x50, 0xc3, 0x9b, 0x30, 0xfc, 0xb4, 0x1a, 0xfe,
+       0x1f, 0x18, 0x5e, 0xc1, 0x76, 0xff, 0xed, 0x66,
+       0xf1, 0xef, 0x63, 0x7c, 0x31, 0x3f, 0xd7, 0x8f,
+       0xc5, 0x7f, 0x8c, 0xf1, 0x5a, 0x16, 0x7f, 0x93,
+       0xc5, 0x0f, 0x62, 0xdc, 0xc3, 0xe2, 0xec, 0xec,
+       0xb5, 0xd2, 0xf7, 0x31, 0x5e, 0xc0, 0xcf, 0x95,
+       0x63, 0xda, 0x11, 0x8f, 0xf1, 0x0c, 0x16, 0x3f,
+       0xc2, 0xe2, 0x28, 0x87, 0x4c, 0x76, 0x6a, 0xdc,
+       0x8c, 0xe3, 0x2c, 0x8e, 0x5a, 0x9d, 0xc9, 0x9e,
+       0x9c, 0xcf, 0x38, 0xc6, 0xf2, 0xff, 0x01, 0xe7,
+       0xea, 0x3e, 0x16, 0xfa, 0xb7, 0x80, 0x91, 0x9f,
+       0xe9, 0x87, 0x98, 0x0b, 0x43, 0xce, 0xf5, 0x4b,
+       0xab, 0x61, 0x7b, 0x65, 0x67, 0xf4, 0x2a, 0xc9,
+       0xb5, 0x9d, 0xe4, 0x93, 0x19, 0x9e, 0x76, 0x24,
+       0xd2, 0x39, 0x7f, 0xdd, 0x4e, 0xda, 0x3d, 0xf3,
+       0xc8, 0x40, 0xf7, 0x35, 0x00, 0x7e, 0xf6, 0x10,
+       0xa6, 0x2d, 0xc6, 0x75, 0x56, 0x35, 0x72, 0x3b,
+       0x6f, 0xad, 0xa9, 0x6c, 0x93, 0x2d, 0x35, 0x9d,
+       0x18, 0x2f, 0xa1, 0x38, 0xcb, 0xe9, 0x15, 0x12,
+       0x59, 0x59, 0x17, 0x68, 0xe4, 0xdc, 0xcf, 0xbc,
+       0xd6, 0x52, 0x1b, 0x3d, 0xd9, 0xa7, 0x5d, 0x86,
+       0xd6, 0xa4, 0x8a, 0x33, 0x63, 0x0c, 0xb8, 0xf2,
+       0xd2, 0xe3, 0x3f, 0x13, 0xbb, 0xf2, 0x7f, 0x49,
+       0x10, 0x0f, 0x76, 0x5c, 0xeb, 0xb2, 0x98, 0xe7,
+       0x93, 0x27, 0xfb, 0xa8, 0x34, 0x3a, 0xe7, 0x4a,
+       0xdf, 0xaf, 0x9d, 0x5e, 0x24, 0x41, 0xd0, 0xa7,
+       0xcd, 0x98, 0xa9, 0x6f, 0x56, 0x9c, 0x19, 0x77,
+       0xa3, 0xb2, 0x3d, 0x00, 0x4c, 0xa7, 0x9f, 0x1d,
+       0xd4, 0xdd, 0x71, 0x6b, 0x65, 0x48, 0x3e, 0x40,
+       0x5a, 0xe5, 0xcc, 0x48, 0x77, 0x62, 0xaa, 0x1f,
+       0xd3, 0xee, 0x53, 0x3c, 0x8c, 0xa2, 0xb7, 0xba,
+       0x93, 0xdd, 0x25, 0x3b, 0xce, 0x4f, 0x10, 0x22,
+       0x9f, 0x7f, 0x9c, 0x8f, 0xaf, 0x8b, 0xca, 0x8e,
+       0x8b, 0x90, 0xdc, 0xc2, 0x43, 0x19, 0xe5, 0x58,
+       0xee, 0x5a, 0xbe, 0x0a, 0xb8, 0x8b, 0xad, 0x00,
+       0x7c, 0xdf, 0xa5, 0x35, 0x40, 0xd5, 0x7e, 0xf1,
+       0x35, 0xaf, 0x4e, 0x1e, 0x9b, 0x4e, 0x75, 0xcb,
+       0x40, 0xde, 0x89, 0x8c, 0x77, 0x3c, 0xa3, 0xf7,
+       0xd9, 0x43, 0x55, 0xfb, 0x7d, 0xdf, 0x15, 0x7b,
+       0x90, 0x02, 0x0e, 0xda, 0x59, 0xfd, 0x33, 0x04,
+       0xeb, 0xf2, 0xd8, 0x55, 0xa3, 0x24, 0x80, 0x9d,
+       0x65, 0x97, 0x81, 0xad, 0x62, 0x66, 0xd2, 0xce,
+       0x47, 0x7e, 0xaa, 0x50, 0xf5, 0xbc, 0xf7, 0x22,
+       0x17, 0x26, 0x1c, 0x25, 0x3a, 0x11, 0xde, 0xe2,
+       0xfd, 0x71, 0xc3, 0xa1, 0xe7, 0xbb, 0xe5, 0xac,
+       0x55, 0x8b, 0x05, 0x79, 0x12, 0xed, 0x95, 0x1b,
+       0xdb, 0x95, 0xaa, 0xbf, 0xf8, 0x9d, 0x0d, 0x6b,
+       0x32, 0x9c, 0xd5, 0x6e, 0x69, 0xf1, 0x50, 0x3e,
+       0xe3, 0xf7, 0x60, 0xad, 0xae, 0xb8, 0x87, 0xed,
+       0xba, 0xe3, 0x7b, 0xee, 0xaa, 0x9d, 0x1b, 0xdc,
+       0x43, 0xf8, 0x38, 0x18, 0x9f, 0xc5, 0xdd, 0x38,
+       0xef, 0x82, 0x2d, 0xc3, 0xf9, 0xb7, 0x74, 0xb2,
+       0x87, 0x5b, 0x4a, 0x89, 0xf2, 0xf1, 0x13, 0x57,
+       0xe2, 0xc5, 0x6b, 0xe3, 0x07, 0xfe, 0xae, 0xf6,
+       0xaa, 0x51, 0xf4, 0xd6, 0x80, 0x6e, 0x05, 0xb7,
+       0x74, 0x34, 0x37, 0x8e, 0xe1, 0x3d, 0x90, 0x4d,
+       0x7d, 0x3b, 0xf1, 0x25, 0x16, 0x7e, 0x98, 0x56,
+       0x3e, 0x33, 0x97, 0x06, 0xb0, 0x0e, 0x1d, 0xb1,
+       0x41, 0x9d, 0x2d, 0x25, 0xf1, 0x53, 0x80, 0x02,
+       0x38, 0x5c, 0xd2, 0xe3, 0xb1, 0xfd, 0x01, 0x8b,
+       0xfb, 0x83, 0x13, 0x90, 0xf3, 0xa5, 0x9a, 0xce,
+       0x39, 0xc7, 0x22, 0xe7, 0xf8, 0x7e, 0x42, 0x94,
+       0x5c, 0x12, 0x7f, 0xab, 0x9b, 0x7a, 0xec, 0x9e,
+       0x6e, 0x19, 0xee, 0xb2, 0xb1, 0x1e, 0x73, 0x30,
+       0xa9, 0x39, 0x48, 0x6a, 0x7e, 0xb4, 0xb5, 0xb0,
+       0x5b, 0xeb, 0x6f, 0xe1, 0x18, 0xd6, 0xd0, 0x19,
+       0x95, 0xda, 0x79, 0x56, 0x4f, 0x87, 0x08, 0x07,
+       0xba, 0x6e, 0x96, 0x5a, 0x8b, 0x20, 0x67, 0x52,
+       0x6b, 0xef, 0x59, 0x95, 0xaa, 0xff, 0x9d, 0x2a,
+       0x35, 0xe4, 0xb5, 0x24, 0xca, 0xe9, 0x69, 0xe2,
+       0x84, 0x35, 0xba, 0xfc, 0xe7, 0xe4, 0x86, 0x9c,
+       0x72, 0x18, 0x27, 0x07, 0x93, 0x9b, 0x53, 0x93,
+       0x1b, 0x72, 0x4b, 0x89, 0x72, 0xcb, 0xd7, 0xb8,
+       0xf1, 0x1a, 0x69, 0x92, 0x1b, 0xab, 0xce, 0x0e,
+       0x28, 0xbf, 0x02, 0xd5, 0x17, 0x1c, 0x80, 0x16,
+       0xf2, 0xc8, 0xb5, 0x39, 0x25, 0x43, 0x76, 0xf5,
+       0x80, 0x99, 0x30, 0x7e, 0x08, 0xce, 0xb0, 0xa5,
+       0xd8, 0x50, 0x6a, 0xb4, 0xda, 0xb3, 0xbd, 0xe3,
+       0xb6, 0x73, 0x29, 0xa9, 0xeb, 0x83, 0xbc, 0x21,
+       0xeb, 0x83, 0x85, 0xea, 0xb9, 0x51, 0xd6, 0x09,
+       0x03, 0x1a, 0x4e, 0xc4, 0xf5, 0xc1, 0x8f, 0x16,
+       0x0d, 0xc6, 0x31, 0xf6, 0x92, 0x98, 0x33, 0x64,
+       0x15, 0x91, 0x3e, 0x24, 0x8f, 0x8a, 0x13, 0x71,
+       0xbe, 0xfb, 0x51, 0xc6, 0x60, 0x1c, 0x63, 0x7e,
+       0xd6, 0x2b, 0x8b, 0x79, 0xaf, 0xe0, 0x8a, 0xe3,
+       0x04, 0x3b, 0xb5, 0x22, 0x8b, 0x46, 0xd7, 0x9d,
+       0xc1, 0xc1, 0xd1, 0x95, 0x92, 0x26, 0xc3, 0x9d,
+       0x0d, 0xfc, 0x6e, 0xf1, 0x9d, 0x8b, 0x98, 0x0f,
+       0xb8, 0x4f, 0xf3, 0xe7, 0xf7, 0xa7, 0x31, 0x0a,
+       0x3d, 0xa6, 0xa4, 0x93, 0x27, 0x7c, 0xa7, 0x80,
+       0xfe, 0xa0, 0x0e, 0xa0, 0x19, 0xee, 0x4c, 0xa2,
+       0xd9, 0x41, 0x3b, 0xaf, 0x4b, 0x84, 0x70, 0xbf,
+       0x5f, 0x27, 0x5e, 0xe6, 0xe7, 0x36, 0x38, 0x13,
+       0xab, 0xab, 0x14, 0xb3, 0xf0, 0x38, 0x7f, 0xff,
+       0x60, 0xf8, 0x9b, 0x0a, 0xc2, 0xe3, 0xf4, 0x9e,
+       0x82, 0x08, 0xdf, 0x47, 0x2f, 0x9b, 0x79, 0x8a,
+       0xfb, 0xba, 0xfe, 0x05, 0xe7, 0x37, 0xb3, 0x30,
+       0x4e, 0xa5, 0x1e, 0xa7, 0x9e, 0xa6, 0x16, 0xcd,
+       0xc1, 0x56, 0x68, 0xfb, 0xf8, 0x7d, 0xd4, 0x68,
+       0xee, 0x45, 0xb4, 0x2b, 0xfc, 0x4e, 0x76, 0x66,
+       0x5d, 0xd9, 0x51, 0x76, 0xfe, 0x8e, 0x99, 0x59,
+       0x81, 0xa3, 0xf4, 0xc6, 0x90, 0x02, 0x49, 0x9b,
+       0x06, 0xdb, 0x77, 0x77, 0xb1, 0x0c, 0x49, 0x4f,
+       0xb3, 0x76, 0x85, 0x59, 0xda, 0x8a, 0x21, 0x69,
+       0x19, 0x98, 0xb6, 0x98, 0xa5, 0x1d, 0x64, 0x69,
+       0x8b, 0x86, 0xa4, 0x59, 0x31, 0xad, 0x82, 0xa5,
+       0x1d, 0x56, 0x57, 0x8f, 0xe1, 0x8d, 0x21, 0x56,
+       0xe7, 0xc3, 0xc7, 0x43, 0x1a, 0x86, 0x56, 0xd7,
+       0x49, 0xe9, 0x82, 0x33, 0xcd, 0xc5, 0xee, 0x1f,
+       0x1f, 0x96, 0xe0, 0x87, 0xdb, 0xf9, 0x4e, 0x2c,
+       0x76, 0x8f, 0xf6, 0xa8, 0x62, 0xb5, 0xd9, 0x6c,
+       0xef, 0x27, 0x84, 0x5f, 0x3f, 0xb2, 0xec, 0xba,
+       0x68, 0x4a, 0x38, 0x89, 0xb0, 0x1f, 0x69, 0x4e,
+       0x88, 0xf0, 0xd3, 0xc3, 0x54, 0xe2, 0x1d, 0x97,
+       0x24, 0x48, 0x9a, 0xba, 0x1a, 0xb0, 0x5c, 0xaf,
+       0x6c, 0x5c, 0x1d, 0x11, 0x73, 0xf8, 0x19, 0x40,
+       0x6c, 0xa5, 0x06, 0xfe, 0x88, 0x77, 0xc3, 0x52,
+       0x9b, 0x7b, 0x43, 0x36, 0x7a, 0xee, 0xe3, 0x9d,
+       0x60, 0x42, 0xfd, 0xb2, 0x88, 0x97, 0xd9, 0x6a,
+       0x6d, 0x1a, 0x6a, 0x31, 0xae, 0x7f, 0x7e, 0xba,
+       0xb6, 0x9a, 0xb5, 0x58, 0x7f, 0x7c, 0xb0, 0xe6,
+       0xc9, 0x3e, 0x19, 0xee, 0xd8, 0xc8, 0x7b, 0xf4,
+       0x8e, 0xf5, 0x69, 0xec, 0xfc, 0x48, 0x2f, 0x78,
+       0x9f, 0x5b, 0x6a, 0xff, 0xd1, 0xfb, 0x8a, 0xa9,
+       0xe8, 0x22, 0xf2, 0xb8, 0x6a, 0x6d, 0x8a, 0x44,
+       0xc0, 0x28, 0xfb, 0x59, 0xec, 0x7c, 0x94, 0x02,
+       0xf3, 0x79, 0x9f, 0x93, 0xcd, 0x3c, 0x55, 0xa5,
+       0xed, 0xf1, 0x7e, 0x5b, 0x49, 0x4f, 0x5d, 0x9f,
+       0xe1, 0x45, 0x8f, 0xca, 0x99, 0x5b, 0x03, 0xc6,
+       0x09, 0xcd, 0x64, 0xe9, 0x71, 0x0d, 0x66, 0x61,
+       0x2b, 0xb2, 0x5f, 0x62, 0x4d, 0x70, 0xb5, 0x94,
+       0x76, 0x43, 0x1c, 0xab, 0x52, 0x25, 0x13, 0x55,
+       0x34, 0x7d, 0x0f, 0x6a, 0xd0, 0x39, 0x4c, 0xff,
+       0x50, 0x84, 0x37, 0x4f, 0xe4, 0xe1, 0xca, 0xc4,
+       0xfd, 0x1c, 0xae, 0x84, 0x4c, 0x5d, 0xac, 0x47,
+       0x15, 0xe3, 0xbd, 0x4e, 0xd0, 0x4f, 0xe8, 0x60,
+       0xcf, 0x57, 0x4c, 0xb9, 0x1d, 0x54, 0x6e, 0x34,
+       0x27, 0x6a, 0x6d, 0xca, 0x0e, 0xcc, 0x89, 0x3e,
+       0xe8, 0x9b, 0x5b, 0xd0, 0x6f, 0x3a, 0xcb, 0xee,
+       0xf4, 0xdd, 0xc5, 0xae, 0xc9, 0xec, 0x7a, 0x37,
+       0xbb, 0xa6, 0x70, 0x69, 0xa1, 0xac, 0xe6, 0xc9,
+       0xf1, 0xd6, 0xc5, 0xac, 0x65, 0xaa, 0xac, 0xac,
+       0x3b, 0x38, 0x67, 0x25, 0x21, 0xb5, 0x2a, 0x67,
+       0x5f, 0xe5, 0x1b, 0xe4, 0x5f, 0xd6, 0x6f, 0x98,
+       0xe0, 0x05, 0xbd, 0x98, 0x96, 0x5a, 0xf5, 0x43,
+       0x76, 0xfa, 0xa2, 0xcc, 0xde, 0x42, 0x75, 0xa6,
+       0x68, 0x67, 0xd0, 0x89, 0x96, 0x9c, 0x7d, 0xde,
+       0x01, 0x86, 0xbb, 0x8b, 0x71, 0x79, 0x99, 0x8d,
+       0xb7, 0xbb, 0x14, 0x7b, 0xf4, 0x0e, 0x2f, 0xdd,
+       0xd1, 0xed, 0x65, 0xbc, 0x0a, 0xc6, 0x7b, 0xc1,
+       0x56, 0x71, 0x26, 0x36, 0x96, 0x9f, 0x74, 0x19,
+       0xad, 0x49, 0x3a, 0x4a, 0x91, 0xd5, 0x44, 0x49,
+       0xc2, 0x92, 0x77, 0x80, 0x31, 0x5a, 0x13, 0xd3,
+       0x84, 0xc5, 0x34, 0x4f, 0x32, 0xce, 0x1f, 0x44,
+       0xcf, 0xc8, 0x3c, 0x28, 0xb4, 0x42, 0x3c, 0x6f,
+       0x59, 0xb4, 0x37, 0xf2, 0xa2, 0x3d, 0x61, 0x7c,
+       0x5d, 0xeb, 0xb9, 0x1e, 0x07, 0x93, 0x20, 0x97,
+       0x14, 0xdd, 0x79, 0x28, 0xbb, 0xc6, 0x6a, 0x9a,
+       0x5c, 0x71, 0x66, 0x02, 0x88, 0xf0, 0xb2, 0x9b,
+       0xe0, 0x14, 0x76, 0xba, 0x25, 0xe3, 0x2b, 0xb0,
+       0xbb, 0x58, 0x7d, 0x9e, 0xe3, 0x06, 0xa8, 0x38,
+       0x63, 0xc4, 0x9f, 0x8e, 0xd9, 0xb1, 0xb2, 0x6b,
+       0xa9, 0x9d, 0xa9, 0xbc, 0x35, 0x17, 0x21, 0x84,
+       0xed, 0x38, 0x44, 0xab, 0x9b, 0x09, 0x1e, 0x08,
+       0x55, 0xb2, 0x37, 0xd2, 0x27, 0xac, 0x24, 0x1c,
+       0xb0, 0xfd, 0x84, 0x65, 0xd7, 0x1e, 0xed, 0xa4,
+       0x3c, 0x28, 0xed, 0xd1, 0xd1, 0xba, 0x55, 0x7e,
+       0x59, 0xdd, 0xc6, 0x37, 0x51, 0xeb, 0xa2, 0x35,
+       0x54, 0x7b, 0x76, 0x48, 0x4d, 0xef, 0x56, 0xef,
+       0xb0, 0xf4, 0x4d, 0x61, 0xbc, 0xe9, 0x14, 0xe1,
+       0xff, 0xf9, 0x8c, 0x16, 0xd6, 0xd2, 0x2a, 0xdb,
+       0x78, 0x49, 0x01, 0x33, 0x96, 0xe5, 0x88, 0x96,
+       0x25, 0x78, 0xbf, 0x0f, 0xa6, 0xa5, 0x16, 0x61,
+       0x34, 0x1b, 0x03, 0x19, 0xa2, 0x59, 0x0d, 0xdd,
+       0x89, 0x5a, 0xbf, 0x1a, 0x67, 0xe1, 0x55, 0xac,
+       0x1e, 0x47, 0x45, 0xd8, 0xb7, 0x04, 0x47, 0x45,
+       0x9d, 0x36, 0x23, 0x4d, 0x60, 0x6f, 0xd4, 0x22,
+       0x5f, 0xf4, 0xa3, 0xee, 0xcc, 0x93, 0x21, 0xa1,
+       0xb6, 0xab, 0x03, 0x0c, 0x75, 0x90, 0x50, 0xc5,
+       0xd6, 0xaf, 0x66, 0x8c, 0xe9, 0x65, 0xb4, 0xa0,
+       0x77, 0xda, 0x31, 0xad, 0x90, 0x8d, 0x79, 0xf4,
+       0x56, 0xf7, 0xa5, 0x23, 0xc6, 0x84, 0x98, 0x52,
+       0x3e, 0x96, 0x12, 0xa6, 0xb3, 0x19, 0x0d, 0x3d,
+       0x98, 0xa4, 0x5e, 0xee, 0x29, 0x97, 0x31, 0x1b,
+       0xe6, 0xcc, 0xa4, 0xbb, 0x6e, 0x19, 0x4e, 0x9a,
+       0x6f, 0x18, 0x2f, 0x9d, 0x1c, 0x3f, 0x25, 0x51,
+       0xc8, 0x8c, 0x0c, 0x94, 0x86, 0x3c, 0xce, 0xd7,
+       0x37, 0x89, 0xe9, 0x54, 0x9a, 0x2c, 0x4c, 0x49,
+       0x9c, 0x92, 0x09, 0x46, 0xc2, 0x77, 0xd3, 0x13,
+       0x36, 0xe3, 0xeb, 0x9b, 0x5e, 0x7f, 0x15, 0xf5,
+       0xa2, 0xe6, 0xe7, 0x33, 0x65, 0x63, 0xc1, 0xbe,
+       0xca, 0x8d, 0x74, 0xb2, 0xe3, 0xe7, 0x1f, 0xaa,
+       0xbe, 0xd1, 0x48, 0x09, 0x96, 0xe6, 0x67, 0x3c,
+       0x9e, 0x45, 0x3c, 0x41, 0x49, 0xa2, 0xf3, 0x03,
+       0xab, 0x9d, 0xae, 0x13, 0x45, 0xd7, 0x56, 0x40,
+       0x42, 0xf4, 0xdc, 0xc0, 0xd5, 0x60, 0xad, 0xf1,
+       0x0e, 0xc8, 0x46, 0xf3, 0x3b, 0x60, 0x9b, 0xce,
+       0x4a, 0x7f, 0x93, 0x4a, 0x37, 0x66, 0xfc, 0xa3,
+       0x68, 0x7d, 0x93, 0xca, 0x34, 0x4d, 0x7c, 0x1c,
+       0x30, 0x76, 0x32, 0x6c, 0x8e, 0xa5, 0xb3, 0xa3,
+       0xcc, 0x33, 0x01, 0x72, 0xdf, 0x21, 0x3a, 0x6d,
+       0xb6, 0xbb, 0xcb, 0xc3, 0x66, 0xb9, 0x4c, 0x11,
+       0x7e, 0x52, 0x80, 0x12, 0x1b, 0x3b, 0x38, 0x87,
+       0x27, 0xa1, 0xfd, 0x1b, 0x5d, 0xc1, 0x5b, 0x3e,
+       0xba, 0x98, 0xb7, 0x7c, 0x68, 0x6b, 0x57, 0xc7,
+       0xb2, 0xfa, 0x66, 0x0d, 0xfa, 0x72, 0x4b, 0xd6,
+       0x0d, 0x3d, 0x87, 0xd2, 0xae, 0xee, 0xa9, 0x9b,
+       0xf7, 0xf3, 0xc8, 0x49, 0xad, 0x8c, 0xbd, 0x27,
+       0x86, 0xbe, 0x77, 0x50, 0x2c, 0xc8, 0x00, 0x6b,
+       0x69, 0x3e, 0xbe, 0x63, 0x6b, 0x26, 0x4c, 0x82,
+       0x2d, 0x34, 0x27, 0x27, 0x66, 0x94, 0x48, 0xd0,
+       0x77, 0xd2, 0x1f, 0xab, 0xf1, 0x59, 0xe2, 0xe8,
+       0xfe, 0xd6, 0xbe, 0x90, 0x52, 0x3a, 0x09, 0xf6,
+       0xae, 0x5b, 0x76, 0x4e, 0x7b, 0xf3, 0xa1, 0x98,
+       0xcd, 0xba, 0x82, 0x69, 0x6e, 0x88, 0x66, 0x5e,
+       0xe1, 0xf2, 0xfb, 0xfb, 0x69, 0xde, 0x15, 0x06,
+       0x8a, 0xeb, 0xb3, 0xe6, 0xd3, 0x5b, 0x10, 0x19,
+       0x38, 0x87, 0xf6, 0x6d, 0x74, 0x24, 0xd2, 0x1e,
+       0x6c, 0xe1, 0x18, 0xbd, 0x19, 0x61, 0xc1, 0xd1,
+       0x01, 0x7a, 0x21, 0x26, 0x5a, 0xbf, 0x4a, 0xed,
+       0xdd, 0x06, 0x76, 0xd6, 0x50, 0x2a, 0x62, 0x0a,
+       0xc5, 0xab, 0x5f, 0xfe, 0x9e, 0x03, 0xd6, 0xd6,
+       0x43, 0x75, 0x4d, 0xbc, 0x96, 0x09, 0x19, 0xb8,
+       0xee, 0xe8, 0xcb, 0xf3, 0x83, 0xc6, 0xab, 0xe9,
+       0x99, 0xee, 0x75, 0x19, 0xce, 0x4c, 0xd4, 0xae,
+       0xbe, 0xb1, 0x83, 0x35, 0x6f, 0x5a, 0x7e, 0x3a,
+       0x34, 0xe1, 0x10, 0xb5, 0x7c, 0xe8, 0x1b, 0x10,
+       0x77, 0x7e, 0x40, 0x65, 0x22, 0x9f, 0x57, 0x65,
+       0x18, 0xc5, 0x76, 0x13, 0x97, 0x59, 0x89, 0xdf,
+       0x1f, 0xcf, 0xa3, 0xfc, 0xf3, 0x07, 0xe5, 0x0f,
+       0xa7, 0x70, 0xc6, 0x4d, 0x7f, 0x9f, 0x34, 0x85,
+       0xbd, 0x67, 0x54, 0x66, 0xe5, 0x4f, 0x11, 0x95,
+       0x0e, 0xe4, 0xb1, 0x11, 0xbd, 0xdc, 0x15, 0x2c,
+       0xb6, 0x06, 0x63, 0x4f, 0x8b, 0xf0, 0xc6, 0x2a,
+       0x49, 0xe6, 0x6f, 0xe5, 0x0c, 0xf7, 0xc4, 0x12,
+       0x4b, 0xb1, 0x94, 0x75, 0x43, 0x7b, 0x8f, 0x7a,
+       0x4e, 0xb0, 0x46, 0x3d, 0x98, 0x06, 0xfc, 0xc9,
+       0x9a, 0x07, 0x33, 0xee, 0x25, 0xea, 0xd3, 0x3f,
+       0x2e, 0x64, 0xa9, 0xdf, 0x15, 0xd8, 0x89, 0x46,
+       0x42, 0x68, 0x3c, 0x9f, 0x7d, 0xcc, 0xf8, 0xe3,
+       0xf9, 0xfe, 0x1e, 0x7d, 0xe3, 0x81, 0x8c, 0xc7,
+       0xf3, 0x79, 0xfb, 0x9f, 0x09, 0xe8, 0x6d, 0xb8,
+       0x5e, 0x19, 0xb7, 0x98, 0xf7, 0x41, 0x75, 0x91,
+       0xdc, 0xab, 0xb5, 0x35, 0xe9, 0x52, 0x54, 0x07,
+       0x9e, 0xd5, 0x74, 0x60, 0x4f, 0x37, 0xae, 0x05,
+       0x56, 0xd0, 0x7b, 0xbd, 0xa3, 0xdc, 0x1f, 0xb1,
+       0xf7, 0x7b, 0x47, 0x4d, 0x55, 0x61, 0xce, 0x47,
+       0x9d, 0x69, 0x10, 0x48, 0x60, 0xfe, 0xff, 0x05,
+       0x3e, 0x9f, 0xe1, 0x75, 0x82, 0x8c, 0x73, 0xfd,
+       0x98, 0xd5, 0x32, 0xe8, 0xb6, 0x67, 0x40, 0x80,
+       0x7a, 0xf1, 0x08, 0xf3, 0x64, 0x4c, 0x81, 0x51,
+       0x18, 0x7e, 0x13, 0xc3, 0x85, 0xb2, 0x1b, 0x29,
+       0x16, 0x21, 0x45, 0x28, 0x03, 0xac, 0x76, 0xc8,
+       0x24, 0x2f, 0x47, 0x82, 0xf8, 0x73, 0x98, 0x56,
+       0x8b, 0x74, 0x7a, 0x3a, 0x85, 0x8e, 0x9d, 0x51,
+       0x66, 0x0a, 0x24, 0xd1, 0x37, 0x71, 0x30, 0x5c,
+       0x8d, 0xe1, 0x91, 0x18, 0x5e, 0x2d, 0x82, 0xce,
+       0x1b, 0xd0, 0x89, 0xe4, 0x11, 0x8d, 0x97, 0x73,
+       0x90, 0x4f, 0x22, 0xf2, 0x29, 0x50, 0xf9, 0x8c,
+       0x65, 0x7c, 0xb6, 0x30, 0x3e, 0xc6, 0x40, 0x9c,
+       0x58, 0xc9, 0xb8, 0x18, 0x03, 0x16, 0xb1, 0x18,
+       0xf3, 0x25, 0x04, 0xcc, 0x62, 0x21, 0x62, 0xa6,
+       0xcb, 0x19, 0x12, 0x24, 0x9c, 0xc6, 0x7c, 0xa0,
+       0xe6, 0x4b, 0x64, 0xf9, 0xea, 0xd4, 0x7c, 0x56,
+       0x91, 0x4a, 0x3d, 0x1f, 0x18, 0x21, 0xc6, 0x57,
+       0x77, 0x06, 0x46, 0x23, 0x6d, 0x17, 0x6a, 0xfe,
+       0x89, 0x0c, 0x40, 0xff, 0x7b, 0x5b, 0xcb, 0x9e,
+       0xaa, 0xef, 0x7a, 0xef, 0xc7, 0x51, 0x0b, 0xf0,
+       0xea, 0xae, 0x1f, 0xa0, 0x1d, 0xea, 0xcd, 0xbf,
+       0x1f, 0x4c, 0x87, 0x3a, 0x20, 0xb2, 0xb3, 0x48,
+       0x3e, 0x6f, 0xff, 0x1e, 0xd1, 0x2c, 0xf1, 0x1d,
+       0x77, 0xad, 0x82, 0xe4, 0x5c, 0x1b, 0xec, 0x2d,
+       0x04, 0xd3, 0x32, 0x8f, 0x9c, 0x2a, 0x58, 0x6b,
+       0x42, 0xe9, 0xc6, 0xe7, 0x43, 0xbb, 0x69, 0xcc,
+       0x3c, 0xd9, 0x02, 0xb0, 0x79, 0x37, 0xcd, 0xa7,
+       0xa1, 0x65, 0xb8, 0x72, 0xba, 0xab, 0x08, 0x74,
+       0x62, 0xb1, 0x60, 0x9d, 0x17, 0xa5, 0x78, 0x32,
+       0xd2, 0xb2, 0x9c, 0xd2, 0x43, 0xb0, 0xac, 0x85,
+       0x52, 0xcf, 0x96, 0xe3, 0x55, 0x2f, 0x0a, 0xc8,
+       0x2d, 0x46, 0xb6, 0xae, 0xd2, 0xa9, 0x27, 0x9c,
+       0xe9, 0x57, 0xe9, 0x8b, 0x2e, 0x63, 0x5e, 0x63,
+       0xc2, 0xc1, 0xb3, 0xcf, 0xcc, 0xf9, 0x59, 0xa4,
+       0xdf, 0x0f, 0xb6, 0x5c, 0x1b, 0xdd, 0x8f, 0x88,
+       0x95, 0x1d, 0x7e, 0xbd, 0x4a, 0x95, 0xee, 0x37,
+       0x88, 0xa9, 0x3b, 0xe9, 0x0e, 0x81, 0x29, 0x30,
+       0x46, 0x84, 0x48, 0xa1, 0x97, 0xfa, 0xc2, 0x86,
+       0xa1, 0x1c, 0xd2, 0xc8, 0x25, 0x05, 0xf4, 0x64,
+       0xdf, 0x8f, 0x33, 0xcd, 0xd8, 0x1b, 0x6c, 0x6c,
+       0x6d, 0x5b, 0x22, 0x20, 0xe6, 0xac, 0x1f, 0xc4,
+       0xcb, 0xb3, 0xdb, 0xd9, 0x07, 0x30, 0xf8, 0xb3,
+       0x6d, 0xf6, 0xf8, 0x4d, 0xc8, 0xca, 0xca, 0xb2,
+       0xc0, 0x6d, 0x9e, 0xac, 0xf1, 0x04, 0xa0, 0x53,
+       0xad, 0x87, 0xfe, 0xd3, 0x1b, 0xe8, 0x9f, 0xc1,
+       0x68, 0x30, 0x52, 0x0c, 0x74, 0x31, 0xb1, 0x26,
+       0xbc, 0xc6, 0x32, 0xac, 0x4e, 0x4f, 0x27, 0x4c,
+       0x33, 0x9f, 0xf0, 0x32, 0x2b, 0xf7, 0xb4, 0x7f,
+       0x46, 0xf4, 0x7c, 0x37, 0x23, 0x9d, 0xef, 0x66,
+       0x3f, 0x3c, 0xf4, 0xbc, 0x68, 0xa2, 0x66, 0x5e,
+       0x23, 0xa7, 0xfe, 0xe8, 0x16, 0xea, 0x2d, 0x43,
+       0xa9, 0xf3, 0x1f, 0x28, 0x70, 0xe4, 0xe0, 0x25,
+       0x3b, 0x1f, 0xf5, 0xd7, 0x3f, 0x74, 0x6c, 0xac,
+       0xd6, 0xd9, 0x12, 0x59, 0x4f, 0x86, 0x59, 0x3f,
+       0x5a, 0xbb, 0xc6, 0x28, 0xc6, 0xaa, 0xef, 0x8a,
+       0x57, 0x25, 0x3b, 0xce, 0x4f, 0x03, 0x33, 0x66,
+       0xcc, 0x10, 0xfc, 0x3a, 0x7e, 0x27, 0x48, 0x88,
+       0xad, 0x38, 0x13, 0x8f, 0x52, 0x29, 0xfa, 0x2d,
+       0xe8, 0x6d, 0xbf, 0x66, 0xff, 0x70, 0xc4, 0x38,
+       0xb0, 0xbf, 0xc3, 0xd8, 0xdf, 0x1f, 0x7b, 0x2a,
+       0x7f, 0x02, 0x0b, 0x29, 0x86, 0x56, 0x77, 0x94,
+       0x92, 0x66, 0xcb, 0x04, 0x5d, 0x98, 0x46, 0x01,
+       0x79, 0x04, 0xdb, 0x96, 0xf6, 0xd9, 0x7e, 0x4d,
+       0xef, 0x44, 0xb0, 0x5e, 0xf8, 0x1d, 0xdd, 0x25,
+       0x8e, 0x24, 0x54, 0xb6, 0x23, 0x65, 0xbc, 0x92,
+       0x1a, 0xa5, 0xb4, 0x13, 0x65, 0x73, 0xdc, 0x2d,
+       0x94, 0x49, 0xf4, 0x3d, 0x2e, 0xd2, 0x75, 0xf6,
+       0x7b, 0x16, 0x7f, 0x2f, 0xd3, 0xd8, 0xc1, 0x1f,
+       0x7a, 0x65, 0x70, 0x03, 0x75, 0x19, 0x35, 0x54,
+       0x97, 0x8f, 0xbf, 0x0a, 0xfc, 0x2d, 0xc1, 0x5f,
+       0x27, 0xfe, 0xd0, 0xef, 0xd2, 0x1d, 0xc6, 0xdf,
+       0x59, 0x11, 0xf4, 0x66, 0xfc, 0x59, 0xf0, 0x57,
+       0x88, 0x3f, 0x1f, 0xfe, 0xaa, 0xf0, 0x87, 0x74,
+       0x7a, 0xa4, 0xd3, 0xbf, 0xc6, 0xf7, 0xef, 0xba,
+       0x32, 0x6b, 0x33, 0x17, 0x4c, 0x2d, 0xa8, 0x6b,
+       0x0a, 0xc2, 0x50, 0x44, 0x76, 0x3e, 0x61, 0xe8,
+       0xae, 0xd9, 0x04, 0xb2, 0x33, 0x54, 0x57, 0xdf,
+       0xb7, 0xe9, 0xbd, 0xc3, 0xbb, 0xf3, 0xdf, 0xdf,
+       0x8f, 0x6b, 0x94, 0xe1, 0xb8, 0x54, 0x66, 0x45,
+       0x32, 0xf1, 0x57, 0xcb, 0xd2, 0x32, 0x6e, 0x4a,
+       0xd7, 0xb3, 0xf4, 0x89, 0xb7, 0x4b, 0x4b, 0xbe,
+       0x30, 0x98, 0xf7, 0x4b, 0x69, 0x0e, 0xf0, 0xfc,
+       0x2a, 0xdd, 0x02, 0x46, 0xf3, 0xc8, 0x4d, 0x34,
+       0x2f, 0x32, 0x9a, 0x47, 0x6f, 0x9b, 0xb6, 0x96,
+       0xa7, 0x0d, 0xcb, 0x4f, 0xe9, 0xfa, 0x8f, 0x3c,
+       0x44, 0x55, 0xf3, 0x6d, 0x9a, 0x71, 0x92, 0x17,
+       0x0d, 0x69, 0xd9, 0xf0, 0x14, 0xf7, 0x4d, 0xed,
+       0xbb, 0x95, 0x42, 0x88, 0x52, 0x0c, 0x72, 0x37,
+       0xa0, 0x85, 0x24, 0x3a, 0xba, 0xea, 0xe6, 0x7d,
+       0x3b, 0x60, 0xc2, 0x99, 0xbb, 0x6f, 0x48, 0x19,
+       0xb7, 0x4b, 0x3f, 0x79, 0x9b, 0x92, 0xd4, 0x56,
+       0xdc, 0xb5, 0x2f, 0x9a, 0x56, 0x7d, 0x3b, 0x29,
+       0xdd, 0xf5, 0xc2, 0x60, 0xfa, 0x2d, 0xd2, 0x72,
+       0xb1, 0x2b, 0xeb, 0x4b, 0x6e, 0x11, 0x64, 0xdb,
+       0x90, 0x9c, 0x75, 0xac, 0x56, 0x37, 0xb5, 0xe9,
+       0xae, 0x0a, 0xc2, 0x92, 0xcd, 0x4a, 0x60, 0x94,
+       0x9e, 0x35, 0x9e, 0xfd, 0xdd, 0x6b, 0x58, 0x2d,
+       0x73, 0x28, 0x85, 0xd2, 0xe6, 0x51, 0x9a, 0xfe,
+       0xa3, 0xb2, 0x04, 0x96, 0x2b, 0x9a, 0x9e, 0xa0,
+       0xb6, 0x32, 0xe3, 0x76, 0xb2, 0xb2, 0x5f, 0xbb,
+       0x8d, 0x36, 0x0c, 0xa7, 0x38, 0x7e, 0x1b, 0x9d,
+       0x18, 0xd2, 0x52, 0xfb, 0xce, 0xa1, 0xd2, 0x3e,
+       0x07, 0xd5, 0x25, 0x55, 0xe8, 0x0e, 0x37, 0x81,
+       0xab, 0xb8, 0x08, 0x55, 0xb6, 0x91, 0x43, 0x5d,
+       0x3b, 0x87, 0xfa, 0x00, 0x87, 0x06, 0x89, 0x43,
+       0xe3, 0x37, 0x38, 0x8c, 0x51, 0x38, 0x34, 0x3d,
+       0xc1, 0x61, 0xec, 0x32, 0x0e, 0xcd, 0x7f, 0xc3,
+       0x61, 0xdc, 0x4a, 0x0e, 0x2d, 0xad, 0x1c, 0x8e,
+       0x78, 0x92, 0x43, 0x6b, 0x3d, 0x87, 0x23, 0xdb,
+       0x38, 0x8c, 0x9f, 0x88, 0xc2, 0x2d, 0xc6, 0x72,
+       0xef, 0xe5, 0x50, 0xf7, 0x00, 0x87, 0xfa, 0x1c,
+       0x0e, 0x0d, 0xe3, 0x39, 0x34, 0x66, 0x73, 0x18,
+       0x73, 0x1f, 0x87, 0xa6, 0x07, 0x39, 0x8c, 0x9d,
+       0xcc, 0xa1, 0x79, 0x1a, 0x87, 0x71, 0x0f, 0x71,
+       0x68, 0x99, 0xc2, 0xe1, 0x88, 0x19, 0x1c, 0x5a,
+       0x27, 0x70, 0x38, 0x32, 0x97, 0xc3, 0x78, 0x0b,
+       0xb8, 0xaa, 0x2b, 0xd0, 0xe6, 0x98, 0x38, 0xd4,
+       0x25, 0x71, 0xa8, 0x8f, 0xe7, 0xd0, 0x3c, 0x96,
+       0xc3, 0xb8, 0xef, 0x80, 0xbb, 0xac, 0x06, 0xeb,
+       0x97, 0xc6, 0xa1, 0x2e, 0x8f, 0x43, 0x7d, 0x26,
+       0x87, 0xe6, 0x42, 0x0e, 0xe3, 0xde, 0x85, 0xa2,
+       0x59, 0x55, 0x48, 0xf7, 0x36, 0x87, 0xba, 0x5f,
+       0x72, 0xa8, 0x3f, 0xce, 0xa1, 0x61, 0x3f, 0x87,
+       0xc6, 0xf7, 0x39, 0x8c, 0x79, 0x87, 0x43, 0xd3,
+       0xaf, 0x38, 0x8c, 0xfd, 0x19, 0x87, 0xe6, 0x7f,
+       0xe3, 0x30, 0xee, 0xd7, 0x1c, 0x5a, 0x7e, 0xce,
+       0xe1, 0x88, 0x33, 0x1c, 0x5a, 0xdf, 0xe2, 0x70,
+       0xe4, 0x2f, 0x38, 0x8c, 0x3f, 0x0b, 0x45, 0x74,
+       0x18, 0x9c, 0xed, 0x3c, 0x87, 0xba, 0xcb, 0x1c,
+       0x9a, 0xc3, 0x08, 0x17, 0x20, 0xfe, 0x20, 0x87,
+       0xba, 0xa3, 0x1c, 0x9a, 0xa7, 0x42, 0x71, 0x09,
+       0xca, 0x7d, 0xd4, 0x21, 0x0e, 0x75, 0x1f, 0x70,
+       0xa8, 0x3f, 0xc6, 0xa1, 0xf9, 0x43, 0x0e, 0xe3,
+       0xca, 0xa0, 0x84, 0xce, 0xbe, 0xb2, 0x95, 0x70,
+       0xa8, 0x9b, 0xcb, 0xa1, 0xde, 0xc7, 0xa1, 0xc1,
+       0xc5, 0xa1, 0x71, 0x0e, 0x87, 0x31, 0x33, 0x39,
+       0x34, 0xcd, 0xe7, 0x30, 0x76, 0x16, 0x87, 0xe6,
+       0x47, 0x39, 0x8c, 0x5b, 0xc0, 0xa1, 0x65, 0x36,
+       0x87, 0x23, 0x1e, 0xe7, 0xd0, 0x5a, 0xc4, 0xe1,
+       0xc8, 0x6a, 0x0e, 0xe3, 0x93, 0xa1, 0xac, 0x92,
+       0xea, 0x77, 0x81, 0x43, 0xdd, 0x75, 0x0e, 0xf5,
+       0x57, 0x38, 0x34, 0xdf, 0xe0, 0x30, 0xee, 0xfb,
+       0x50, 0x51, 0xec, 0xc2, 0xfa, 0xfd, 0x4f, 0x0e,
+       0x75, 0x3f, 0xe2, 0x50, 0xbf, 0x93, 0x43, 0xc3,
+       0x36, 0x0e, 0x8d, 0xaf, 0x73, 0x18, 0xf3, 0xcf,
+       0x1c, 0x9a, 0x7e, 0xcc, 0x61, 0xec, 0xff, 0xe2,
+       0xd0, 0xfc, 0xbf, 0x39, 0x8c, 0x7b, 0x83, 0x43,
+       0xcb, 0xbf, 0x70, 0x38, 0xe2, 0xa7, 0x1c, 0x5a,
+       0xff, 0x89, 0xc3, 0x91, 0x3f, 0xe4, 0x30, 0x7e,
+       0x3b, 0x42, 0x92, 0xf7, 0xcb, 0x1c, 0xea, 0x76,
+       0x73, 0x98, 0xf4, 0x1a, 0x87, 0xe6, 0x37, 0x39,
+       0xb4, 0x6c, 0x45, 0x48, 0xf2, 0x7f, 0x89, 0x43,
+       0xdd, 0x2e, 0x0e, 0xf5, 0xaf, 0x72, 0x68, 0xde,
+       0xc7, 0x61, 0x5c, 0x29, 0x54, 0x54, 0x93, 0x7c,
+       0xe7, 0x71, 0xa8, 0xaf, 0xe4, 0xd0, 0xfc, 0x18,
+       0x87, 0x71, 0x5e, 0x0e, 0x47, 0xc5, 0xc1, 0x6c,
+       0x1f, 0xb5, 0x37, 0x86, 0x43, 0xdd, 0x1d, 0x1c,
+       0xea, 0x13, 0x38, 0x34, 0xe8, 0x38, 0x34, 0x8e,
+       0xe6, 0x30, 0x26, 0x96, 0x43, 0xd3, 0x9d, 0x1c,
+       0xc6, 0x8e, 0xe4, 0xd0, 0x7c, 0x0f, 0x87, 0x71,
+       0x77, 0x71, 0x68, 0x19, 0xc5, 0xe1, 0x88, 0x71,
+       0x1c, 0x5a, 0x0d, 0x1c, 0x8e, 0x1c, 0xc3, 0x61,
+       0xfc, 0x24, 0xf0, 0xcd, 0xa6, 0x71, 0x92, 0xce,
+       0xa1, 0x2e, 0x9f, 0x43, 0x7d, 0x16, 0x87, 0xe6,
+       0xe9, 0x1c, 0xc6, 0x2d, 0x41, 0x48, 0xf5, 0x94,
+       0x39, 0xd4, 0x2d, 0xe7, 0x50, 0xdf, 0xc2, 0xa1,
+       0x79, 0x35, 0x87, 0x71, 0x17, 0xa1, 0xda, 0x4d,
+       0x76, 0xe6, 0x63, 0x0e, 0x75, 0x9f, 0x71, 0xa8,
+       0xbf, 0xca, 0xa1, 0xe1, 0x23, 0x0e, 0x8d, 0x9f,
+       0x72, 0x18, 0xf3, 0x09, 0x87, 0xa6, 0x3f, 0x72,
+       0x18, 0xfb, 0x3b, 0x0e, 0xcd, 0x5f, 0x70, 0x18,
+       0xf7, 0x39, 0x87, 0x96, 0xdf, 0x73, 0x38, 0x22,
+       0xc2, 0xa1, 0xf5, 0x37, 0x1c, 0x8e, 0xfc, 0x03,
+       0x87, 0xf1, 0xdf, 0x82, 0xea, 0x1a, 0x92, 0xdb,
+       0xdf, 0x72, 0xa8, 0xdf, 0xc8, 0xa1, 0x61, 0x0d,
+       0x87, 0xc6, 0xe7, 0x38, 0x8c, 0xf9, 0x36, 0x87,
+       0xa6, 0xbf, 0xe3, 0x30, 0xf6, 0xbf, 0x71, 0x68,
+       0xfe, 0x1f, 0x1c, 0xc6, 0xfd, 0x3d, 0x87, 0x96,
+       0xff, 0xce, 0xe1, 0x88, 0x7f, 0xe4, 0xd0, 0xfa,
+       0x14, 0x87, 0x23, 0xbf, 0xc7, 0x61, 0xfc, 0x3a,
+       0x84, 0xa4, 0x1f, 0xcf, 0x73, 0x98, 0xf4, 0x2c,
+       0x87, 0xe6, 0xa7, 0x11, 0x92, 0x3e, 0x6c, 0xe2,
+       0x50, 0xff, 0x0c, 0x87, 0xe6, 0x06, 0x84, 0x0b,
+       0x11, 0x1f, 0xe4, 0x50, 0xff, 0x02, 0x87, 0xe6,
+       0x17, 0x39, 0x8c, 0x4b, 0x84, 0x1a, 0x9f, 0x1b,
+       0xd3, 0x53, 0x38, 0x34, 0x1b, 0xa1, 0xa6, 0x9a,
+       0xe2, 0x56, 0x0e, 0xcd, 0x07, 0xc0, 0x87, 0x76,
+       0xdc, 0x09, 0x9a, 0x3d, 0xdf, 0x00, 0xee, 0x22,
+       0x6c, 0xf7, 0xe8, 0x2e, 0x84, 0xd5, 0x08, 0x7b,
+       0xc1, 0x5d, 0x32, 0x07, 0xa1, 0x03, 0xdc, 0xb3,
+       0xca, 0x10, 0x76, 0x83, 0xbb, 0xb2, 0x04, 0xa1,
+       0x0d, 0xdc, 0x55, 0xd8, 0x7f, 0xa3, 0x43, 0xe0,
+       0xa6, 0xfe, 0x1e, 0x5d, 0x05, 0xee, 0x79, 0x94,
+       0xcf, 0x8f, 0x90, 0xf2, 0xd9, 0xa1, 0xa8, 0x02,
+       0xe3, 0x09, 0x27, 0x11, 0xa2, 0xdd, 0x4c, 0xa8,
+       0x45, 0x88, 0xf9, 0x13, 0xf6, 0x20, 0x9c, 0x87,
+       0xf0, 0x08, 0xda, 0x0b, 0x6c, 0x57, 0x42, 0x27,
+       0x42, 0x6c, 0x47, 0x42, 0x0f, 0x8e, 0x4f, 0x8a,
+       0x1f, 0x46, 0x48, 0xf1, 0x4b, 0x50, 0x49, 0xa7,
+       0xfc, 0x25, 0x5c, 0x83, 0xaa, 0x12, 0x92, 0xe3,
+       0x09, 0x84, 0x98, 0xdf, 0x50, 0x87, 0x10, 0xf5,
+       0x61, 0x8c, 0x07, 0xaa, 0x3c, 0x88, 0x4f, 0xf8,
+       0x2e, 0x42, 0x6c, 0x47, 0xc2, 0x08, 0x84, 0x54,
+       0x4e, 0x39, 0xc2, 0x72, 0x84, 0x66, 0x84, 0x94,
+       0xff, 0x14, 0x42, 0xe2, 0xbb, 0x10, 0x21, 0xf1,
+       0x5d, 0x0c, 0x55, 0x74, 0xc4, 0x63, 0xc2, 0x0f,
+       0x10, 0x52, 0xbe, 0xfb, 0x11, 0x52, 0xbe, 0x0c,
+       0x84, 0x44, 0xdf, 0x8f, 0x90, 0xe8, 0x57, 0x21,
+       0x24, 0xfa, 0x02, 0x94, 0x0b, 0xb5, 0xa3, 0x0f,
+       0x21, 0xd1, 0xad, 0x40, 0x48, 0xed, 0x78, 0x05,
+       0x6a, 0x5c, 0x44, 0xb7, 0x03, 0x21, 0xd1, 0x3d,
+       0x02, 0x35, 0x74, 0x64, 0x65, 0xc2, 0xdd, 0x08,
+       0xb1, 0xfd, 0x09, 0xdf, 0x84, 0x1a, 0x9a, 0xa7,
+       0x12, 0x34, 0xb9, 0x6b, 0xfd, 0xa0, 0xc9, 0x5d,
+       0xeb, 0x87, 0x87, 0x81, 0x1d, 0x5c, 0x98, 0xb0,
+       0x17, 0x21, 0xf1, 0x5b, 0x0f, 0x35, 0xb5, 0x54,
+       0xbf, 0x2d, 0x08, 0x89, 0xcf, 0x3f, 0x20, 0x24,
+       0xfe, 0x9b, 0xa1, 0x66, 0x01, 0xe1, 0x7f, 0x82,
+       0x90, 0xe8, 0xfe, 0x04, 0xb5, 0x45, 0xd8, 0x0f,
+       0x09, 0x80, 0xf2, 0xa7, 0x23, 0xfa, 0xd6, 0x22,
+       0xc4, 0xfe, 0x18, 0xa3, 0x57, 0x4f, 0x47, 0x3c,
+       0x0d, 0xde, 0x59, 0x18, 0x4f, 0xac, 0x40, 0x48,
+       0xf3, 0x43, 0x33, 0x87, 0x89, 0x1d, 0x1c, 0xde,
+       0xb1, 0x88, 0xc3, 0x11, 0xa9, 0xe0, 0xa5, 0xf9,
+       0x6a, 0x84, 0x80, 0x90, 0xc6, 0xdb, 0x00, 0x87,
+       0x77, 0xd4, 0xc0, 0xac, 0x79, 0x95, 0x18, 0x2f,
+       0x46, 0x58, 0x35, 0x44, 0x4f, 0x9c, 0xe0, 0xab,
+       0xa1, 0xf6, 0x2f, 0x45, 0x88, 0xf9, 0x12, 0x44,
+       0x84, 0x54, 0x4f, 0x4d, 0x7f, 0xfe, 0x15, 0xf5,
+       0x8e, 0xe4, 0xf8, 0x1e, 0xcc, 0x77, 0x11, 0xdd,
+       0x6f, 0xa1, 0xd6, 0x4d, 0xf5, 0x8e, 0x44, 0xd8,
+       0xbd, 0x83, 0x51, 0x12, 0x98, 0x71, 0x5d, 0xfa,
+       0xfd, 0xeb, 0x2c, 0x56, 0x2e, 0x41, 0xec, 0x55,
+       0x8c, 0xf5, 0xb0, 0x58, 0x3e, 0xc6, 0xce, 0x63,
+       0xec, 0x94, 0x76, 0x97, 0x21, 0xf6, 0x03, 0x8c,
+       0x1d, 0x65, 0xb1, 0x47, 0x31, 0x86, 0xfe, 0xf5,
+       0xf7, 0xd9, 0x33, 0xc2, 0x3b, 0x5b, 0x30, 0xb6,
+       0x17, 0x63, 0x5d, 0x2c, 0x86, 0xeb, 0xfa, 0xd8,
+       0x57, 0x31, 0xb6, 0x9d, 0xc5, 0x7e, 0x80, 0xb1,
+       0x17, 0x31, 0xb6, 0x89, 0xc5, 0x36, 0x63, 0x6c,
+       0x03, 0xc6, 0xd6, 0xe1, 0xca, 0x4c, 0x5a, 0x66,
+       0xc1, 0xeb, 0xaa, 0x16, 0x63, 0x77, 0x21, 0x9c,
+       0xad, 0x6c, 0xa7, 0x95, 0x31, 0xc3, 0x2c, 0x64,
+       0x18, 0xa1, 0xb2, 0x7d, 0x27, 0xa3, 0xd9, 0xc9,
+       0x68, 0x8e, 0x33, 0x1a, 0xfa, 0xa6, 0x90, 0xf6,
+       0x06, 0xaf, 0xd5, 0x06, 0xf7, 0xc9, 0x02, 0xbb,
+       0x6b, 0x9e, 0x41, 0x4f, 0xbe, 0x64, 0x33, 0xc3,
+       0x98, 0x7c, 0x9d, 0x09, 0x61, 0xf1, 0x92, 0xfb,
+       0x2e, 0xfe, 0x25, 0x20, 0x4c, 0xb5, 0xb0, 0xf5,
+       0xf8, 0x15, 0xc4, 0x5e, 0x25, 0x9c, 0x7b, 0x34,
+       0xf1, 0xf1, 0x47, 0xf9, 0xb0, 0x75, 0xd4, 0xfb,
+       0x6c, 0xed, 0xd5, 0x8d, 0x1c, 0x26, 0xab, 0xf7,
+       0xe3, 0xbb, 0x7d, 0x9d, 0x41, 0xf0, 0x03, 0x62,
+       0x26, 0xf0, 0xd3, 0xbc, 0x90, 0x8b, 0x03, 0xd7,
+       0xa8, 0xb4, 0x32, 0x7f, 0x08, 0x57, 0xad, 0xa7,
+       0x36, 0x60, 0xfc, 0xc4, 0xda, 0x74, 0xfd, 0xc7,
+       0xeb, 0x4f, 0x3c, 0x75, 0x82, 0xaf, 0xdd, 0xde,
+       0x17, 0x4f, 0x22, 0xfd, 0xbd, 0x72, 0x2a, 0xe5,
+       0xb5, 0xd9, 0x89, 0x62, 0x29, 0x40, 0x17, 0xe6,
+       0xd0, 0x61, 0x8e, 0x1d, 0x27, 0xd6, 0x3e, 0x0d,
+       0x2a, 0xdd, 0x39, 0x56, 0xd7, 0x0c, 0x4e, 0xa7,
+       0x00, 0x3c, 0x33, 0xa4, 0x05, 0x66, 0x5f, 0xe7,
+       0x47, 0xeb, 0x13, 0x41, 0xbc, 0xe0, 0xeb, 0x54,
+       0xa9, 0x9b, 0x11, 0xbf, 0x48, 0x36, 0xfa, 0x3a,
+       0x45, 0x4b, 0xaa, 0x87, 0x79, 0xae, 0xc7, 0xe5,
+       0x14, 0xc9, 0xef, 0x0d, 0x29, 0x49, 0x9c, 0x62,
+       0x0a, 0xbb, 0x0f, 0x73, 0x61, 0x51, 0x5a, 0x62,
+       0x06, 0xed, 0xaa, 0x2a, 0x14, 0xca, 0x30, 0x47,
+       0x1a, 0xf1, 0x2f, 0x62, 0xcf, 0xc9, 0x68, 0x4d,
+       0x7f, 0xe3, 0xd9, 0xc0, 0xa8, 0xae, 0x6c, 0x1b,
+       0xcc, 0x7f, 0x37, 0xd2, 0xef, 0x75, 0x2d, 0xb5,
+       0x5f, 0x5c, 0xff, 0xb4, 0x4b, 0xe5, 0x7f, 0x8a,
+       0xf1, 0xfc, 0x85, 0x02, 0x91, 0x64, 0xf1, 0x58,
+       0x75, 0xa7, 0xc0, 0xd7, 0xcb, 0xdd, 0x8a, 0xbe,
+       0x98, 0x3f, 0x0b, 0x78, 0x1f, 0xe5, 0x16, 0xcf,
+       0xa4, 0xb6, 0x22, 0xdd, 0xac, 0xd2, 0xc6, 0x17,
+       0xf5, 0xeb, 0x32, 0x12, 0x33, 0x22, 0x91, 0x5d,
+       0x85, 0x54, 0xb7, 0xa2, 0x7e, 0x58, 0x18, 0x04,
+       0xef, 0x68, 0x25, 0x95, 0x76, 0x83, 0x05, 0x62,
+       0x6d, 0xc9, 0x58, 0x62, 0x4a, 0xd7, 0xdd, 0xb2,
+       0xd5, 0x3b, 0x06, 0x4b, 0xbc, 0x9a, 0x36, 0x11,
+       0xcc, 0x19, 0xde, 0xa2, 0x8b, 0x60, 0x15, 0x4f,
+       0x09, 0x15, 0x36, 0x9b, 0x92, 0x24, 0xc1, 0x17,
+       0x74, 0xd2, 0xdd, 0xb6, 0x95, 0x1b, 0xba, 0xee,
+       0x52, 0xcc, 0xde, 0xd1, 0x72, 0x1f, 0x2e, 0xbe,
+       0x8a, 0x04, 0x3d, 0xae, 0xbe, 0xb1, 0x2c, 0x8b,
+       0x70, 0xff, 0xe4, 0x49, 0x53, 0xd2, 0x3b, 0x26,
+       0x66, 0x3d, 0x0a, 0xc5, 0xda, 0x89, 0xae, 0xdb,
+       0x67, 0x04, 0x8b, 0xb3, 0xa3, 0xe1, 0x15, 0xc5,
+       0x39, 0xd1, 0x70, 0x47, 0x71, 0x6e, 0x34, 0x1c,
+       0x2a, 0xce, 0x8b, 0x86, 0x9f, 0x2e, 0x7e, 0x20,
+       0x1a, 0xee, 0x2c, 0xce, 0x8f, 0x86, 0x9f, 0x29,
+       0x7e, 0x30, 0x1a, 0xde, 0xe0, 0x1a, 0xe4, 0xbf,
+       0xc9, 0x35, 0xc8, 0x7f, 0xb3, 0x6b, 0x90, 0xff,
+       0x0b, 0xae, 0x41, 0xfe, 0x5b, 0x5d, 0x83, 0xfc,
+       0x5f, 0x72, 0x0d, 0xf2, 0xdf, 0xe1, 0x1a, 0xe4,
+       0xff, 0xaa, 0x6b, 0x90, 0x7f, 0x57, 0x55, 0x51,
+       0x34, 0xbc, 0x7b, 0x9e, 0xdb, 0xa7, 0x85, 0x0f,
+       0x14, 0xb9, 0x8a, 0x7c, 0x6a, 0xf8, 0x50, 0x91,
+       0xcb, 0xa5, 0x85, 0x8f, 0x54, 0x15, 0x45, 0x69,
+       0x8e, 0xb3, 0xaf, 0xf3, 0xa9, 0xf8, 0x32, 0xed,
+       0x90, 0xdb, 0xed, 0x33, 0x8e, 0xcd, 0x1a, 0x0c,
+       0x1f, 0x9f, 0x3b, 0x18, 0x7e, 0xb3, 0xa4, 0xb6,
+       0x44, 0x2b, 0xcd, 0x58, 0x51, 0x32, 0x4f, 0xab,
+       0x35, 0x3b, 0xf3, 0x13, 0x75, 0x22, 0x43, 0xb6,
+       0xd1, 0x19, 0x52, 0xf0, 0x2a, 0x6a, 0xff, 0x44,
+       0x19, 0x74, 0x26, 0x31, 0x1d, 0xb1, 0x8f, 0xc8,
+       0x76, 0x86, 0x7d, 0x1e, 0xb1, 0x8f, 0xd2, 0xdb,
+       0x89, 0xa4, 0x4d, 0xe7, 0xe3, 0x85, 0x44, 0xd1,
+       0x2c, 0xc1, 0xc0, 0x09, 0xc4, 0x7c, 0xc8, 0x4e,
+       0xb5, 0x73, 0xfa, 0x3a, 0xa7, 0xe8, 0x12, 0x50,
+       0x97, 0x06, 0xe4, 0x9d, 0x74, 0x82, 0xb9, 0xd5,
+       0x13, 0xf2, 0x84, 0xf9, 0x7e, 0x55, 0x31, 0x15,
+       0x31, 0xf3, 0x11, 0x13, 0xd6, 0x9e, 0x66, 0x8b,
+       0xb6, 0x9d, 0xfc, 0x2b, 0x0b, 0xdb, 0x73, 0xd9,
+       0x6e, 0xe9, 0xb2, 0x9e, 0xd4, 0x71, 0x95, 0xed,
+       0x53, 0x74, 0xb8, 0xa6, 0x5f, 0x91, 0x0a, 0x6c,
+       0xff, 0xa6, 0x95, 0x4a, 0x8d, 0x2c, 0xc1, 0x92,
+       0xd7, 0x8b, 0x57, 0x10, 0x33, 0x45, 0xc5, 0xd4,
+       0x22, 0x66, 0x87, 0x78, 0x5a, 0xd0, 0xf1, 0x1c,
+       0x98, 0x72, 0xbf, 0xac, 0xf7, 0x75, 0xf2, 0xd1,
+       0x89, 0x14, 0x7b, 0x8b, 0x43, 0xa2, 0x5e, 0xda,
+       0xc5, 0xb8, 0xdc, 0xcf, 0x30, 0x3b, 0x8e, 0x87,
+       0xc4, 0xab, 0xd1, 0xf4, 0x2d, 0x1b, 0x43, 0xe2,
+       0x79, 0x9e, 0x7b, 0xc2, 0xcf, 0xb1, 0xe4, 0x13,
+       0x83, 0x6f, 0xfd, 0x2b, 0x16, 0xe9, 0x35, 0x3a,
+       0x7d, 0xa4, 0xc3, 0xc4, 0xbe, 0x7b, 0xb3, 0xad,
+       0x23, 0xb6, 0xb2, 0x9d, 0xbe, 0xd8, 0x57, 0x76,
+       0xc2, 0x1f, 0xa9, 0x6c, 0x07, 0x9d, 0xe7, 0x93,
+       0xad, 0x6c, 0x97, 0x40, 0xd9, 0x49, 0x4f, 0x37,
+       0x18, 0x3c, 0xce, 0x03, 0xe1, 0x3c, 0x5d, 0x05,
+       0x85, 0x5c, 0x07, 0xc2, 0x27, 0x5c, 0x1e, 0xb7,
+       0xdb, 0x4d, 0xb1, 0x03, 0xe1, 0xe3, 0x6b, 0x2b,
+       0xce, 0xe8, 0x62, 0x68, 0x4c, 0xec, 0x09, 0xed,
+       0x77, 0xb9, 0x8d, 0xde, 0xd0, 0x12, 0x63, 0x71,
+       0xa8, 0xd4, 0xe8, 0x5d, 0x83, 0x70, 0x4d, 0xa9,
+       0x91, 0xde, 0x56, 0xe2, 0x36, 0xb6, 0xec, 0x2c,
+       0x71, 0x0a, 0xc2, 0x4e, 0xfe, 0xfc, 0x31, 0xc5,
+       0xeb, 0x52, 0x9e, 0xf5, 0x38, 0xc3, 0x4f, 0x85,
+       0xf6, 0xe7, 0x01, 0xf1, 0x73, 0x64, 0x80, 0x3e,
+       0xb4, 0x3f, 0x8c, 0x36, 0x44, 0xb4, 0x9f, 0xeb,
+       0x3c, 0xf7, 0x1d, 0x95, 0xee, 0x1a, 0xd2, 0x41,
+       0x44, 0x26, 0xaa, 0x83, 0x4f, 0x79, 0x8d, 0x38,
+       0x16, 0xd7, 0xa6, 0xe2, 0xd8, 0xd0, 0xdd, 0xa3,
+       0x8d, 0x43, 0x1a, 0x3b, 0x1d, 0x97, 0x82, 0x91,
+       0xe8, 0x98, 0x33, 0xd0, 0x98, 0xeb, 0xdf, 0x31,
+       0x38, 0xe6, 0xf2, 0x26, 0x82, 0x91, 0x8d, 0x39,
+       0x13, 0x8d, 0x39, 0x87, 0x3a, 0xb2, 0xf8, 0x68,
+       0x62, 0xe3, 0x48, 0xc7, 0x46, 0x90, 0x9e, 0x8d,
+       0x1d, 0x03, 0x1b, 0x35, 0x46, 0x36, 0x5e, 0x62,
+       0xd8, 0x48, 0x31, 0xb1, 0x31, 0x12, 0xcb, 0x46,
+       0x87, 0x99, 0x8d, 0x8b, 0x38, 0x36, 0x22, 0x2c,
+       0x6c, 0x2c, 0x8c, 0x60, 0xa3, 0xc0, 0xca, 0xf4,
+       0x7f, 0x24, 0xd3, 0xfc, 0x78, 0xa6, 0xf3, 0xa3,
+       0x98, 0xb6, 0xdb, 0x98, 0xd6, 0x8e, 0x66, 0xda,
+       0x9e, 0xc0, 0xf4, 0x73, 0x4c, 0x35, 0x5d, 0x13,
+       0x99, 0xce, 0xdf, 0xc1, 0x34, 0x3c, 0x89, 0xe9,
+       0xf6, 0x9d, 0xb4, 0x53, 0x7c, 0x75, 0x1f, 0xfb,
+       0x6e, 0x38, 0x3b, 0xf9, 0x93, 0xbf, 0x63, 0x99,
+       0x51, 0x56, 0x72, 0x19, 0xcc, 0x13, 0x9d, 0x60,
+       0x4c, 0xf7, 0xd0, 0xdb, 0xa7, 0x99, 0x31, 0xfb,
+       0xe8, 0x7e, 0x61, 0xa8, 0xd5, 0xd8, 0xf1, 0xa4,
+       0x6f, 0x9d, 0x60, 0xaa, 0x0e, 0xc9, 0xa6, 0xc4,
+       0x93, 0xee, 0x64, 0x71, 0x9e, 0xcd, 0x3e, 0x86,
+       0x7d, 0xe1, 0x28, 0xc1, 0xbe, 0x13, 0xe4, 0xb1,
+       0x2b, 0x74, 0xd5, 0xeb, 0x7c, 0x4f, 0x57, 0xaf,
+       0x53, 0x4c, 0x5d, 0x76, 0xba, 0x8f, 0xbc, 0xe5,
+       0xe9, 0xe2, 0xe2, 0xc4, 0x70, 0xe2, 0x41, 0xef,
+       0xb7, 0x94, 0x4c, 0x71, 0x6f, 0x51, 0x4f, 0xe4,
+       0xc6, 0x0a, 0xb0, 0xe9, 0x18, 0x85, 0x99, 0xe5,
+       0xb8, 0x5a, 0xdd, 0x49, 0x54, 0xd5, 0x4f, 0x3b,
+       0x8c, 0x89, 0xbf, 0x9e, 0x73, 0x34, 0x32, 0x90,
+       0x18, 0xf6, 0x7e, 0x4b, 0xde, 0x20, 0x58, 0x8a,
+       0xb0, 0xfc, 0x0d, 0xdf, 0xc9, 0x08, 0xed, 0x0e,
+       0xb5, 0xa4, 0x52, 0x58, 0x30, 0x14, 0x87, 0x32,
+       0x42, 0x82, 0x21, 0xc1, 0x70, 0xfe, 0xbb, 0xa9,
+       0xff, 0x5a, 0xfd, 0x94, 0xdc, 0x7f, 0xa0, 0x03,
+       0x0c, 0xa2, 0x3e, 0xe1, 0x5f, 0xe9, 0x8c, 0xf8,
+       0xaa, 0xd0, 0xcd, 0x6f, 0x87, 0xe6, 0x0e, 0xac,
+       0x61, 0x2d, 0xaa, 0x38, 0x33, 0x6e, 0x35, 0xfb,
+       0xa2, 0xcc, 0xd9, 0x41, 0x0a, 0xde, 0x56, 0xef,
+       0x86, 0xa5, 0xf9, 0x15, 0x27, 0xc1, 0x90, 0xe6,
+       0x79, 0x3f, 0xfc, 0x8b, 0xfd, 0xaf, 0x1f, 0x51,
+       0x8a, 0xfd, 0x60, 0x13, 0x96, 0xc6, 0x8f, 0xa1,
+       0x33, 0x82, 0x06, 0xc6, 0xbc, 0x4f, 0x5c, 0xc4,
+       0x1e, 0x4f, 0xa8, 0xd4, 0x99, 0x20, 0x8c, 0xd9,
+       0x4f, 0xb1, 0x31, 0x3a, 0x4a, 0x11, 0x4f, 0x54,
+       0x75, 0x0a, 0x19, 0x60, 0x4c, 0x80, 0xf3, 0x9d,
+       0xa9, 0x27, 0x51, 0x12, 0x5a, 0x4d, 0xd8, 0x69,
+       0xf5, 0x5f, 0x5e, 0x8f, 0x58, 0x03, 0xdd, 0xbd,
+       0x37, 0x05, 0xd5, 0x6f, 0xba, 0x99, 0x30, 0x9c,
+       0x4c, 0x35, 0x3b, 0xdb, 0xc7, 0x4e, 0xb6, 0xb8,
+       0xac, 0xd8, 0x52, 0x3d, 0x69, 0xce, 0x44, 0xba,
+       0x03, 0xb7, 0x9e, 0xce, 0xa7, 0xf7, 0x5c, 0xe6,
+       0xdf, 0xad, 0x18, 0x3c, 0x25, 0xbf, 0x8b, 0x9d,
+       0xd9, 0xd5, 0x6c, 0x62, 0xcf, 0x18, 0x78, 0xcc,
+       0xb8, 0x8c, 0xc7, 0x8c, 0x0f, 0x3a, 0x41, 0xcf,
+       0xbf, 0x40, 0x40, 0xdf, 0x17, 0x74, 0x3a, 0xdd,
+       0x35, 0xd1, 0x7d, 0xc6, 0x1b, 0xb5, 0xd3, 0xfc,
+       0x8b, 0xae, 0x9a, 0xe1, 0xf8, 0x2f, 0x70, 0xc6,
+       0xab, 0xc2, 0xf9, 0xce, 0xa2, 0x78, 0xf1, 0x1a,
+       0x27, 0x5b, 0x1d, 0x63, 0xc2, 0x1d, 0x91, 0xbe,
+       0x2a, 0x67, 0x7e, 0x48, 0xa4, 0x27, 0xe2, 0x23,
+       0x65, 0xfa, 0x0e, 0xcc, 0x81, 0x84, 0x90, 0x7a,
+       0xa6, 0x7f, 0xaa, 0xf6, 0xfd, 0x09, 0xfd, 0x9b,
+       0xbe, 0x9a, 0x5d, 0x35, 0x2d, 0x7a, 0xa9, 0x72,
+       0x17, 0x3b, 0xdd, 0x9f, 0x7d, 0x0d, 0x45, 0xa6,
+       0xd3, 0xfd, 0xc5, 0x4d, 0x5e, 0x50, 0x26, 0xa9,
+       0x54, 0x9b, 0x55, 0xaa, 0x0c, 0x77, 0xf5, 0x10,
+       0xba, 0xe9, 0xfc, 0x2b, 0x00, 0x8a, 0x55, 0x84,
+       0xc8, 0x62, 0x95, 0xb2, 0x05, 0xfb, 0x26, 0x96,
+       0x7f, 0xff, 0xaa, 0xd4, 0x2c, 0xdb, 0xdd, 0x35,
+       0xec, 0x29, 0xdf, 0x66, 0x94, 0x1c, 0x7d, 0x17,
+       0x25, 0x5f, 0xfd, 0xe2, 0x51, 0x2f, 0xbd, 0x9b,
+       0x31, 0x45, 0x1f, 0xd4, 0x49, 0xc6, 0x34, 0xf6,
+       0x05, 0xc7, 0x70, 0x78, 0xc8, 0x2e, 0x0d, 0x75,
+       0xaf, 0x07, 0xdf, 0xf3, 0x51, 0xd4, 0x6b, 0x56,
+       0x9f, 0xbf, 0x6c, 0x60, 0x92, 0xda, 0xe0, 0xf6,
+       0x39, 0xc5, 0x0c, 0xfa, 0x1a, 0xe6, 0xd7, 0xf9,
+       0x87, 0x7d, 0xfb, 0x01, 0xbf, 0x3b, 0x1b, 0x88,
+       0x39, 0x70, 0xa0, 0xda, 0x35, 0xe4, 0xdc, 0xbc,
+       0xeb, 0x6a, 0x1d, 0xe9, 0xbc, 0x57, 0xf6, 0x2d,
+       0x2e, 0xad, 0x6c, 0x7d, 0x37, 0x2f, 0x5b, 0xdf,
+       0x7d, 0xbb, 0xb2, 0xb1, 0x4e, 0x71, 0x7f, 0x59,
+       0xf9, 0x7e, 0x76, 0x82, 0x53, 0x68, 0xac, 0x12,
+       0x9f, 0xa3, 0xaf, 0x76, 0x1d, 0x20, 0xfe, 0xfb,
+       0x03, 0x99, 0xa2, 0x39, 0x87, 0xbe, 0xae, 0x31,
+       0x79, 0x78, 0x9d, 0x2a, 0xce, 0x18, 0x50, 0xa3,
+       0xbe, 0x54, 0x32, 0x46, 0x2e, 0x99, 0x54, 0x8f,
+       0x43, 0x5f, 0xcd, 0x9e, 0x46, 0x7d, 0x2f, 0x4c,
+       0x4f, 0xcf, 0x6e, 0x95, 0xcf, 0xf8, 0xaf, 0xf9,
+       0x37, 0x28, 0x1f, 0x56, 0x9b, 0x98, 0x6a, 0xd7,
+       0x78, 0xe0, 0xff, 0x86, 0x49, 0x68, 0xe3, 0x10,
+       0x09, 0x19, 0xb9, 0x84, 0xb4, 0x3a, 0xe8, 0xbb,
+       0xa9, 0x0e, 0xfa, 0xee, 0xdb, 0xcb, 0xe9, 0x2f,
+       0xa9, 0xc7, 0xad, 0x72, 0x7a, 0x6e, 0x98, 0x9c,
+       0x86, 0xd6, 0x8c, 0xcb, 0xc9, 0xf3, 0x49, 0x5f,
+       0x9f, 0x5a, 0xc7, 0x8e, 0xa1, 0xdf, 0x9a, 0x48,
+       0x65, 0xb5, 0xa5, 0x1a, 0xfc, 0x82, 0xde, 0x18,
+       0xdc, 0x3e, 0xe9, 0x55, 0x1a, 0x3f, 0x63, 0x1a,
+       0x56, 0xcc, 0x26, 0xff, 0x33, 0xd1, 0x6e, 0xcb,
+       0x13, 0xa0, 0xe4, 0x0f, 0x68, 0x40, 0x97, 0x40,
+       0x0b, 0x54, 0xe1, 0xf5, 0x34, 0x6c, 0x1d, 0xb3,
+       0x44, 0xe7, 0x85, 0x5e, 0xbc, 0xee, 0xd1, 0x39,
+       0xc7, 0x2c, 0xd1, 0xa7, 0xeb, 0x36, 0xe0, 0x75,
+       0x93, 0xee, 0xec, 0x98, 0x25, 0x06, 0xbd, 0xde,
+       0x81, 0x57, 0xbf, 0x3e, 0x94, 0x70, 0x1c, 0xad,
+       0xd9, 0x01, 0x4d, 0x97, 0xcd, 0x74, 0x56, 0xf1,
+       0x99, 0xde, 0x24, 0xe5, 0x0a, 0xea, 0x3c, 0xeb,
+       0xab, 0xb3, 0xa2, 0xfa, 0xed, 0x94, 0xf0, 0xc5,
+       0xb2, 0x3c, 0xd7, 0x71, 0xfa, 0xe7, 0x1d, 0xb3,
+       0xd6, 0x06, 0x07, 0x3b, 0x20, 0x52, 0xc2, 0x6a,
+       0x90, 0x98, 0x83, 0x25, 0xb3, 0x1a, 0x95, 0x5c,
+       0x15, 0x80, 0xd7, 0xf3, 0x78, 0xf8, 0x00, 0xd5,
+       0x74, 0x7f, 0xc2, 0xc6, 0xbf, 0xb4, 0x3e, 0x15,
+       0x67, 0x4c, 0x6c, 0xa7, 0xc1, 0x59, 0xff, 0x60,
+       0x79, 0xc7, 0xd9, 0x0e, 0x0f, 0xa7, 0xde, 0xfb,
+       0x9c, 0x62, 0x4e, 0x5f, 0x70, 0x27, 0x96, 0x2e,
+       0x5e, 0xfb, 0xb2, 0xf2, 0x37, 0x3a, 0xff, 0xe3,
+       0x35, 0x88, 0x8f, 0x25, 0x0b, 0xa8, 0xcf, 0x63,
+       0x23, 0xbb, 0x1c, 0xfd, 0x1f, 0xfb, 0xe0, 0x57,
+       0xe8, 0x24, 0x98, 0xb6, 0x91, 0xbe, 0x25, 0xfe,
+       0x56, 0x78, 0x89, 0xde, 0xed, 0xec, 0xea, 0xd0,
+       0x87, 0x96, 0x19, 0x1d, 0x85, 0xfa, 0x27, 0x73,
+       0xc3, 0x84, 0xbb, 0xe0, 0x21, 0xf8, 0xad, 0x43,
+       0x8c, 0xe2, 0x00, 0x51, 0xf0, 0x27, 0x2e, 0x54,
+       0x97, 0x2e, 0x17, 0x52, 0xea, 0xaa, 0x9d, 0x8c,
+       0xf2, 0x80, 0x27, 0x1c, 0x42, 0x1c, 0xa3, 0x3e,
+       0x8c, 0x65, 0xd1, 0x8e, 0xa7, 0x6d, 0xeb, 0xc6,
+       0xc9, 0xfc, 0xbd, 0x8b, 0x6d, 0x6f, 0x1d, 0x45,
+       0x6f, 0x7f, 0x5d, 0x74, 0x94, 0x20, 0x8d, 0x6a,
+       0x3f, 0x28, 0x7c, 0xc8, 0xea, 0xa0, 0xe7, 0xa0,
+       0x4a, 0x83, 0xd7, 0xa9, 0x64, 0xb2, 0x70, 0x44,
+       0x49, 0x43, 0xf8, 0x30, 0xc2, 0x14, 0x84, 0xd3,
+       0x10, 0x26, 0x22, 0xcc, 0x40, 0x68, 0x45, 0x98,
+       0x89, 0xd0, 0x58, 0xed, 0x14, 0xbb, 0x8b, 0xd8,
+       0x77, 0x55, 0x12, 0x7a, 0x01, 0x7c, 0x58, 0x73,
+       0xa8, 0x52, 0x04, 0x96, 0x0a, 0x8a, 0x9d, 0xe5,
+       0x06, 0xc5, 0x86, 0x70, 0x22, 0x9d, 0x9d, 0xcd,
+       0x4b, 0x90, 0x4f, 0xb8, 0x47, 0xd3, 0x1b, 0x4b,
+       0xec, 0x7b, 0x56, 0xf9, 0x4b, 0x1e, 0x73, 0xb3,
+       0x3a, 0x6a, 0xba, 0x22, 0xb1, 0xf3, 0xb6, 0x43,
+       0xea, 0x37, 0x03, 0xbb, 0xb9, 0xf5, 0x27, 0x89,
+       0x4d, 0xe5, 0xa3, 0x89, 0x7d, 0x89, 0xc8, 0xab,
+       0xea, 0xf2, 0xd8, 0x52, 0x5b, 0x29, 0x2e, 0xd6,
+       0xf1, 0xb7, 0x15, 0x7f, 0xbd, 0xa5, 0x19, 0x3a,
+       0x27, 0xfe, 0x36, 0xe0, 0xef, 0x6c, 0x69, 0x86,
+       0xde, 0xc1, 0xdf, 0x6d, 0x23, 0x6e, 0x74, 0xc2,
+       0xeb, 0xba, 0x71, 0xb4, 0x8f, 0x4e, 0x2b, 0xe7,
+       0xcb, 0xf8, 0xb3, 0xde, 0xf1, 0xf2, 0xbd, 0x62,
+       0x7f, 0xbe, 0x04, 0xb6, 0xf3, 0xc4, 0xab, 0xbe,
+       0x43, 0x97, 0x01, 0x96, 0xff, 0x53, 0xa7, 0xe7,
+       0x9e, 0x0d, 0x39, 0x0f, 0xa8, 0xdf, 0x25, 0xdf,
+       0xb6, 0x6e, 0xac, 0x52, 0xcc, 0x64, 0x36, 0x36,
+       0xda, 0x06, 0x55, 0x37, 0xa8, 0x3f, 0xa9, 0x0d,
+       0xb6, 0x42, 0x98, 0x9b, 0x50, 0x08, 0xaf, 0xbc,
+       0x6e, 0xfb, 0x21, 0xd6, 0xfd, 0x75, 0xac, 0x3b,
+       0xc2, 0xde, 0xd7, 0xb1, 0xee, 0x3f, 0xc4, 0xba,
+       0x23, 0x3c, 0xfb, 0x43, 0xac, 0x7b, 0xe9, 0x01,
+       0xac, 0x37, 0x1f, 0x15, 0x21, 0x55, 0x4f, 0x6a,
+       0x86, 0x96, 0x22, 0x17, 0x33, 0xa9, 0xfd, 0x27,
+       0x95, 0x32, 0x45, 0xdb, 0x3b, 0xb1, 0xdc, 0xed,
+       0xb0, 0xd1, 0x13, 0x7f, 0x13, 0x7d, 0xf3, 0x33,
+       0x8a, 0x15, 0x47, 0xef, 0x03, 0x8b, 0x0d, 0x30,
+       0x0d, 0x7d, 0xf4, 0x3f, 0x5e, 0xe2, 0xdf, 0x03,
+       0xe5, 0x5f, 0x9f, 0xc2, 0x54, 0x75, 0xcf, 0x22,
+       0x7a, 0x1a, 0x4f, 0xaa, 0x14, 0x87, 0x91, 0xab,
+       0x7e, 0x18, 0x4d, 0xe9, 0x20, 0x0d, 0xe3, 0xa5,
+       0x43, 0x4a, 0x9c, 0x67, 0xff, 0xf8, 0xa2, 0x46,
+       0x79, 0xd6, 0x49, 0x69, 0x7c, 0x4d, 0x5a, 0x8d,
+       0x0e, 0x24, 0x8e, 0xf5, 0x51, 0xa3, 0x5f, 0x17,
+       0xc0, 0x06, 0x3d, 0x9d, 0xb4, 0xff, 0x1c, 0xd7,
+       0x99, 0x4c, 0x1a, 0x7d, 0x4e, 0xb3, 0x0e, 0x62,
+       0xe7, 0xbd, 0x85, 0xd4, 0x33, 0x48, 0xb7, 0x3b,
+       0xad, 0xc5, 0xae, 0xe3, 0x1d, 0x60, 0xf9, 0xb8,
+       0xec, 0xf8, 0x7e, 0x3b, 0xae, 0xe6, 0xd1, 0xdb,
+       0x36, 0x15, 0x87, 0x30, 0x34, 0x99, 0x9e, 0x42,
+       0xa6, 0xa1, 0x9d, 0x4c, 0xbd, 0x4b, 0x71, 0xee,
+       0x5c, 0xdb, 0x62, 0xda, 0xb4, 0xc6, 0x17, 0x12,
+       0xaf, 0x57, 0xaf, 0x91, 0x2d, 0x5e, 0xfa, 0x42,
+       0xe7, 0x5b, 0xa3, 0x8b, 0x23, 0x11, 0x0c, 0x25,
+       0x56, 0xbd, 0x85, 0x1e, 0x82, 0x89, 0x62, 0xa2,
+       0xd9, 0x6d, 0xa0, 0x77, 0x61, 0x44, 0x2b, 0x79,
+       0x1f, 0xf5, 0x7a, 0x3f, 0x74, 0xe3, 0x3a, 0xdd,
+       0x16, 0x16, 0xf7, 0x62, 0xe9, 0xe3, 0xe8, 0x0c,
+       0xf3, 0x87, 0xb7, 0x1c, 0x81, 0x98, 0xcf, 0x3e,
+       0x02, 0xd8, 0xfc, 0x7c, 0x08, 0x46, 0xb9, 0x9d,
+       0xa0, 0x5b, 0xb7, 0x15, 0xe0, 0x3e, 0x1b, 0x3a,
+       0xc9, 0xf4, 0x8d, 0x8a, 0x06, 0xf2, 0x81, 0xc9,
+       0x7b, 0x56, 0xf5, 0xc2, 0xcf, 0xda, 0xd3, 0x40,
+       0xa7, 0x86, 0x04, 0x98, 0xbd, 0x1a, 0x2d, 0xe6,
+       0x15, 0x82, 0xb2, 0x33, 0x79, 0xfe, 0x91, 0xc8,
+       0x00, 0x59, 0xf4, 0xd1, 0xd2, 0xdf, 0xbe, 0x97,
+       0x67, 0x49, 0x38, 0xe0, 0x73, 0xe1, 0xcc, 0x71,
+       0x96, 0x5b, 0x21, 0x9a, 0x2b, 0x69, 0x67, 0x51,
+       0xb9, 0x95, 0xde, 0x82, 0x2e, 0x4f, 0xc9, 0x29,
+       0xb4, 0xd2, 0x57, 0x35, 0xdf, 0x65, 0xbb, 0x63,
+       0x0c, 0x3c, 0x9d, 0xec, 0x73, 0x39, 0xed, 0x5b,
+       0xb8, 0x6d, 0x7a, 0xa4, 0x2f, 0xdd, 0x13, 0x84,
+       0x3c, 0x78, 0x7a, 0x00, 0x46, 0xec, 0x5a, 0x49,
+       0x6f, 0x48, 0xca, 0x19, 0xfc, 0xbd, 0x49, 0x41,
+       0xef, 0x71, 0xd2, 0x9b, 0x52, 0xb2, 0x1d, 0xb5,
+       0x84, 0xed, 0x74, 0x98, 0x93, 0xf9, 0x7e, 0xd8,
+       0x3f, 0x23, 0xfd, 0x64, 0x3a, 0xfb, 0xfe, 0xb3,
+       0xe8, 0xa4, 0x15, 0x20, 0x7d, 0xd1, 0x56, 0xc9,
+       0x64, 0x7e, 0xcb, 0x08, 0x9e, 0xcf, 0xbd, 0x99,
+       0xfe, 0x71, 0xfa, 0xc0, 0x88, 0xd5, 0xa8, 0x21,
+       0xba, 0x63, 0xca, 0xab, 0xfe, 0x08, 0xed, 0x34,
+       0x52, 0x32, 0x55, 0xde, 0x6c, 0xf6, 0xd7, 0xde,
+       0x61, 0xa1, 0x9d, 0xa1, 0xb7, 0xab, 0x09, 0xae,
+       0xee, 0xbd, 0x9c, 0xbf, 0x3f, 0x32, 0x34, 0x1f,
+       0xd5, 0x4c, 0x2d, 0x0b, 0xeb, 0x37, 0xbc, 0x76,
+       0xc2, 0xbf, 0x0a, 0xff, 0x4a, 0xb5, 0x23, 0x1f,
+       0x4c, 0x99, 0x7a, 0x73, 0x09, 0x5e, 0xc6, 0x77,
+       0xa9, 0xfa, 0xde, 0x9e, 0x32, 0x55, 0x7b, 0xeb,
+       0x53, 0xc9, 0x2a, 0xea, 0x81, 0x11, 0xc1, 0x88,
+       0xdf, 0xe2, 0x5b, 0xeb, 0xb5, 0xcf, 0xc3, 0xfc,
+       0x4a, 0x41, 0x00, 0xaa, 0x3b, 0xdd, 0x76, 0xdf,
+       0x9a, 0xd7, 0xdf, 0x55, 0x8c, 0x74, 0xf6, 0xee,
+       0xce, 0x0e, 0x18, 0xa1, 0x54, 0xf1, 0x92, 0xc8,
+       0xce, 0x28, 0x99, 0xd4, 0xe6, 0x6e, 0xf7, 0x41,
+       0x2c, 0xff, 0xfd, 0x03, 0xd4, 0x4e, 0xb8, 0x20,
+       0xa7, 0x88, 0x5d, 0x83, 0x69, 0x51, 0x19, 0x44,
+       0x30, 0xed, 0x88, 0x92, 0x78, 0x3b, 0x19, 0xb8,
+       0x1f, 0xba, 0xb5, 0x9e, 0xe1, 0x10, 0xae, 0xda,
+       0x70, 0x15, 0xb6, 0x1e, 0x57, 0xb0, 0x37, 0x7a,
+       0x7c, 0x4e, 0xf4, 0x35, 0xa0, 0xda, 0x25, 0x5f,
+       0xc5, 0x35, 0x6d, 0x21, 0x62, 0x37, 0x6b, 0xd4,
+       0x3a, 0x43, 0x94, 0x3a, 0x09, 0xf1, 0x93, 0x90,
+       0xda, 0x31, 0x94, 0x7a, 0x7d, 0xcb, 0x6d, 0x28,
+       0x13, 0x90, 0x6a, 0xd3, 0x50, 0xaa, 0x1b, 0x3d,
+       0xb7, 0xa1, 0x8a, 0x97, 0xe0, 0x8b, 0xf3, 0x83,
+       0x54, 0xc3, 0x29, 0x86, 0x7e, 0x71, 0xb5, 0xd4,
+       0xe2, 0x09, 0x7b, 0xf6, 0x67, 0x78, 0xf8, 0x5b,
+       0x39, 0x98, 0x8b, 0xed, 0x37, 0x2f, 0x8f, 0xf1,
+       0xba, 0x1e, 0xa1, 0xf7, 0x8e, 0x8c, 0x4b, 0x92,
+       0xe9, 0x3d, 0x2c, 0xd3, 0x59, 0xde, 0xe6, 0x55,
+       0x11, 0xe1, 0x6d, 0xfa, 0x97, 0xfb, 0x36, 0xc9,
+       0x81, 0xde, 0xc8, 0xf5, 0x9e, 0x7f, 0x93, 0xed,
+       0x83, 0x9c, 0x4f, 0xbb, 0xdd, 0x06, 0x3c, 0xe1,
+       0x49, 0xb0, 0x1e, 0x25, 0x27, 0xc4, 0x78, 0xf8,
+       0xbb, 0x79, 0x17, 0x30, 0xdf, 0x4f, 0xdf, 0x87,
+       0x69, 0x1d, 0x38, 0xa9, 0xd3, 0x57, 0xc5, 0xd9,
+       0x57, 0xc2, 0x59, 0x4a, 0x3f, 0xfb, 0xea, 0xf1,
+       0x8b, 0xd3, 0x3a, 0x9e, 0x03, 0x78, 0x91, 0x7a,
+       0xd3, 0x3b, 0x20, 0x9b, 0xa6, 0x75, 0x3c, 0x0d,
+       0x84, 0x2b, 0xfe, 0x0e, 0xac, 0x46, 0xbd, 0xb3,
+       0xa9, 0x6f, 0x32, 0x01, 0x9c, 0xe4, 0x14, 0x4a,
+       0x12, 0x7a, 0x30, 0x06, 0x3a, 0xdf, 0x4e, 0xb6,
+       0xe6, 0xb2, 0xb7, 0xac, 0xcb, 0xcd, 0x22, 0xc0,
+       0x5e, 0x9c, 0x61, 0x17, 0xf3, 0xf7, 0x79, 0x74,
+       0x1b, 0xe8, 0x2c, 0x59, 0x83, 0x99, 0x7d, 0xc7,
+       0x3b, 0x82, 0xd2, 0xd8, 0x40, 0xab, 0x9a, 0x72,
+       0x6b, 0x2a, 0x1c, 0xc7, 0x95, 0x63, 0x1e, 0xcc,
+       0xbc, 0x9c, 0x04, 0x3f, 0x0e, 0xb7, 0xa6, 0xbe,
+       0xb1, 0xbf, 0x79, 0xac, 0x04, 0x03, 0x5b, 0x53,
+       0x0b, 0x91, 0x0b, 0x74, 0xed, 0xa3, 0xd6, 0x2b,
+       0x26, 0x8c, 0x21, 0x14, 0x5c, 0x74, 0x6f, 0xa3,
+       0xe2, 0x4c, 0x9c, 0x41, 0x2d, 0xd5, 0x4e, 0xf5,
+       0xf0, 0x5e, 0x90, 0xab, 0xac, 0x2b, 0x61, 0x04,
+       0xb5, 0x79, 0x59, 0xa9, 0x04, 0xc6, 0x57, 0x44,
+       0x2b, 0x96, 0x24, 0xa8, 0x75, 0x64, 0xde, 0x84,
+       0x37, 0x22, 0x67, 0xaa, 0xeb, 0x9d, 0x34, 0xed,
+       0xcb, 0xe7, 0xc3, 0xbf, 0x44, 0xea, 0xc3, 0x51,
+       0xa7, 0x5f, 0x42, 0x77, 0x20, 0x71, 0x05, 0x52,
+       0x87, 0x7a, 0x75, 0x1c, 0xcb, 0x4a, 0x56, 0xeb,
+       0xde, 0x2d, 0x81, 0xfa, 0x35, 0xe8, 0x17, 0xa7,
+       0x51, 0x89, 0xfd, 0x28, 0x19, 0xb5, 0xe7, 0x9e,
+       0x8c, 0x44, 0x6d, 0x2c, 0xca, 0x93, 0xd3, 0xa3,
+       0xc1, 0x0c, 0x61, 0x9e, 0x3a, 0xbd, 0x0d, 0x9e,
+       0x94, 0x16, 0xe9, 0x36, 0x48, 0xb5, 0x3a, 0xf6,
+       0xf5, 0x72, 0xd9, 0x3e, 0xe4, 0xdb, 0x14, 0x63,
+       0xf9, 0xb7, 0x29, 0x74, 0x54, 0x93, 0x1b, 0x7c,
+       0x7e, 0x44, 0xc9, 0x3e, 0x7f, 0x33, 0x2f, 0xe4,
+       0x93, 0x4c, 0xfc, 0xa4, 0x44, 0xe4, 0x63, 0xc3,
+       0x98, 0x55, 0xf7, 0xc6, 0x60, 0x0e, 0x94, 0xa3,
+       0x9e, 0xeb, 0x8c, 0x3f, 0x2e, 0xfa, 0x1d, 0x5d,
+       0xbd, 0x7f, 0x4c, 0x42, 0x16, 0x98, 0x76, 0xf2,
+       0xf7, 0x7b, 0x0e, 0x47, 0xae, 0x55, 0x9c, 0x71,
+       0x1a, 0x86, 0xd1, 0x66, 0x0f, 0xa1, 0xad, 0xff,
+       0x6a, 0x5a, 0x47, 0xa1, 0xee, 0xee, 0x28, 0x35,
+       0x79, 0x5c, 0x0f, 0xde, 0x8e, 0xde, 0xbc, 0x81,
+       0x74, 0x34, 0x12, 0x30, 0x77, 0x23, 0x7c, 0x9e,
+       0xed, 0x80, 0x39, 0xcb, 0x5b, 0x81, 0x92, 0x46,
+       0xad, 0xb0, 0xed, 0xe3, 0x5e, 0xa3, 0xf7, 0x72,
+       0xd5, 0x29, 0xbf, 0x71, 0xb9, 0x9e, 0x49, 0x06,
+       0x22, 0x6e, 0x6c, 0x13, 0x8e, 0x3d, 0x92, 0x6f,
+       0x24, 0x9f, 0x49, 0x8d, 0xe2, 0x99, 0x01, 0x08,
+       0x8e, 0x3b, 0xbe, 0xc6, 0x3c, 0x1a, 0x62, 0x14,
+       0xbd, 0x6f, 0x0d, 0x4b, 0xb5, 0xb3, 0x94, 0x84,
+       0x39, 0x47, 0x22, 0x3d, 0x2c, 0x6e, 0xf6, 0xae,
+       0x99, 0x7f, 0x8a, 0xed, 0xa2, 0xd9, 0x8d, 0x2b,
+       0x67, 0xfe, 0x4d, 0xd8, 0xf0, 0x50, 0xb9, 0xe5,
+       0xc0, 0x71, 0x17, 0x93, 0xfa, 0x17, 0xf2, 0x54,
+       0xdd, 0x06, 0x7e, 0xb2, 0x93, 0xfb, 0x1b, 0xb6,
+       0x7e, 0xac, 0x21, 0xce, 0x8e, 0x37, 0x0e, 0xa3,
+       0xbe, 0x1a, 0xa9, 0x66, 0x8a, 0x85, 0xea, 0x51,
+       0x83, 0x29, 0xe2, 0x65, 0xae, 0x15, 0x44, 0xc5,
+       0x7a, 0xe5, 0x0b, 0x5d, 0x77, 0xd4, 0xda, 0x3b,
+       0xd5, 0xde, 0x60, 0x1c, 0x95, 0xa9, 0xbc, 0x24,
+       0xaa, 0xd3, 0x8d, 0xd5, 0xac, 0x3f, 0xbe, 0xe0,
+       0x25, 0x70, 0x5d, 0x42, 0xec, 0x62, 0x29, 0x85,
+       0xe7, 0xe0, 0x3c, 0xbb, 0x9d, 0xb9, 0x38, 0x1a,
+       0xa1, 0x9f, 0x38, 0xea, 0xf9, 0x6a, 0x03, 0xdc,
+       0x46, 0xa4, 0x73, 0x4e, 0x89, 0xe3, 0x14, 0x39,
+       0x8c, 0xfa, 0xb8, 0x2b, 0x27, 0xdb, 0xd6, 0x9f,
+       0xfa, 0x78, 0x3e, 0x9c, 0x73, 0x9e, 0x73, 0xed,
+       0x74, 0x2e, 0xb3, 0x52, 0x7d, 0x37, 0x3a, 0x1d,
+       0xba, 0xe0, 0x0d, 0xd1, 0x86, 0x52, 0xd6, 0x6d,
+       0x70, 0x05, 0xf5, 0xa2, 0x89, 0xee, 0x17, 0x57,
+       0x1d, 0xa4, 0xb3, 0x8a, 0xa7, 0xc4, 0xdd, 0x54,
+       0xce, 0x53, 0x80, 0xf9, 0x0f, 0xd1, 0x6e, 0x4d,
+       0x13, 0xe6, 0xd5, 0x8b, 0x46, 0xcc, 0x85, 0xb3,
+       0xfc, 0x0d, 0xbd, 0xd7, 0x48, 0x6f, 0x09, 0xdf,
+       0x48, 0xaf, 0x38, 0x03, 0x6c, 0x85, 0xb1, 0xc6,
+       0xb6, 0xda, 0x38, 0xad, 0xc3, 0x09, 0x90, 0x86,
+       0xd6, 0x65, 0x4f, 0x3a, 0x9b, 0xcd, 0x26, 0x97,
+       0x83, 0xe0, 0x28, 0xdc, 0x42, 0xdf, 0x59, 0xd6,
+       0xc3, 0x0b, 0xd3, 0x9c, 0x90, 0x46, 0xbf, 0x21,
+       0x5a, 0xdb, 0x40, 0xb0, 0xce, 0x8e, 0x16, 0x63,
+       0x6c, 0x18, 0x69, 0x94, 0xcb, 0x2a, 0x87, 0x44,
+       0xc5, 0x3a, 0xe7, 0xe7, 0x91, 0x9d, 0xb9, 0xec,
+       0x14, 0x06, 0xf6, 0xfe, 0xe4, 0x1a, 0x66, 0xd1,
+       0xce, 0x66, 0x15, 0xce, 0xc5, 0x3f, 0xa1, 0x82,
+       0xce, 0x85, 0xf1, 0x9e, 0xc7, 0x5f, 0x0f, 0x0b,
+       0x5d, 0xc0, 0xdf, 0xa5, 0x15, 0x96, 0xe5, 0x90,
+       0x5a, 0x5e, 0x74, 0x31, 0x0f, 0xd2, 0xca, 0x7f,
+       0x44, 0xef, 0xc2, 0x1f, 0xb7, 0x2e, 0x2c, 0xfe,
+       0x8e, 0x7c, 0xcd, 0xea, 0x2b, 0xfe, 0x8e, 0x72,
+       0xc5, 0x36, 0x09, 0xf4, 0x09, 0x93, 0xc0, 0x14,
+       0x8e, 0x3d, 0x10, 0xdb, 0x8d, 0xaa, 0xb1, 0x1b,
+       0xed, 0x40, 0xc9, 0x25, 0xe3, 0x74, 0xf1, 0x84,
+       0xef, 0xa9, 0x92, 0x4b, 0x90, 0x21, 0x24, 0xa7,
+       0x26, 0x87, 0xbf, 0x7d, 0xe0, 0xdb, 0xdd, 0xa1,
+       0xd0, 0x9a, 0x4c, 0x98, 0x62, 0x29, 0xb9, 0x14,
+       0xe9, 0xf6, 0xc3, 0xaa, 0xb8, 0xd4, 0xe4, 0x1f,
+       0x86, 0x68, 0x8f, 0x59, 0xda, 0xe3, 0xe1, 0x6f,
+       0x77, 0xad, 0xc3, 0xd5, 0xdc, 0x4d, 0x74, 0x7e,
+       0x98, 0x5a, 0x08, 0x33, 0x88, 0x6a, 0xe8, 0x8f,
+       0x4e, 0xf9, 0x53, 0x73, 0x78, 0x99, 0x55, 0x39,
+       0xaf, 0xe4, 0x73, 0xeb, 0xa2, 0x98, 0xab, 0x19,
+       0x14, 0xd3, 0x57, 0x3d, 0x99, 0x3a, 0x49, 0x0f,
+       0x42, 0x94, 0x5b, 0x46, 0x98, 0x72, 0xb1, 0xd4,
+       0xf3, 0xfc, 0xb9, 0x84, 0x37, 0x22, 0x1a, 0x71,
+       0x5d, 0x97, 0x83, 0x3a, 0x19, 0xa1, 0xdd, 0x98,
+       0xac, 0xad, 0x3d, 0x94, 0xce, 0x42, 0x97, 0x88,
+       0x4f, 0x86, 0x87, 0xa5, 0xd2, 0x79, 0x04, 0x85,
+       0x9a, 0xfc, 0x07, 0x1a, 0x86, 0xca, 0xff, 0xd4,
+       0x4d, 0xf2, 0x8f, 0x4a, 0xfb, 0x7a, 0x94, 0x3e,
+       0x8f, 0x49, 0xb7, 0x77, 0xe6, 0x70, 0x3b, 0x96,
+       0x0b, 0xfd, 0x9c, 0xcf, 0x24, 0x26, 0xf5, 0xcc,
+       0x98, 0xd3, 0xeb, 0xc8, 0xea, 0x95, 0x1b, 0x15,
+       0xf6, 0x5c, 0xa0, 0x3c, 0x46, 0xb6, 0xe5, 0x14,
+       0x1a, 0x66, 0xa4, 0x1f, 0xe2, 0xff, 0x68, 0xf5,
+       0xcb, 0xe9, 0x67, 0xfe, 0x36, 0x46, 0x90, 0xac,
+       0xd4, 0x82, 0xf2, 0x98, 0x8a, 0x33, 0xa3, 0xb0,
+       0x6e, 0xf4, 0x2e, 0x60, 0xb9, 0x0e, 0xfb, 0x13,
+       0xed, 0x6a, 0xb9, 0x7e, 0x85, 0x45, 0x4a, 0x9f,
+       0xf9, 0x5b, 0xa3, 0xd3, 0xb4, 0x12, 0x22, 0x14,
+       0xe7, 0x6d, 0xc6, 0x96, 0x5e, 0xe2, 0xb2, 0xe2,
+       0x5f, 0xa1, 0xf6, 0xd2, 0xf9, 0xdf, 0xe5, 0xb5,
+       0x9d, 0xc2, 0x40, 0xf1, 0x77, 0x8a, 0xbf, 0xc3,
+       0xec, 0x3b, 0x48, 0x7e, 0xd7, 0x6f, 0xc1, 0x4c,
+       0x6f, 0x43, 0xc2, 0x56, 0xa9, 0x41, 0xad, 0x4d,
+       0x66, 0x19, 0x9b, 0xc1, 0xd5, 0x3a, 0x55, 0xf8,
+       0xe9, 0x4d, 0xd9, 0x71, 0x19, 0x61, 0xfe, 0x0f,
+       0xf5, 0xe8, 0x3a, 0x4f, 0xcf, 0x60, 0x6f, 0x5e,
+       0x56, 0x75, 0xae, 0x7e, 0x52, 0x48, 0x49, 0x87,
+       0x73, 0x74, 0x0f, 0xfc, 0x69, 0x57, 0x8f, 0x6e,
+       0x40, 0x30, 0x48, 0xab, 0x5c, 0x3d, 0x37, 0x80,
+       0xce, 0x32, 0x47, 0xee, 0xce, 0x9c, 0x42, 0x1d,
+       0x48, 0x35, 0x18, 0x2a, 0xe0, 0x6b, 0x23, 0x07,
+       0x30, 0x6a, 0x0b, 0xd2, 0xf9, 0x50, 0xdb, 0xad,
+       0x95, 0xed, 0xe1, 0x6f, 0xa5, 0xc1, 0x4f, 0xd6,
+       0xa6, 0xea, 0x4f, 0xac, 0x3d, 0xf7, 0x1d, 0xf3,
+       0x7e, 0x18, 0x77, 0x60, 0x6d, 0x68, 0x8d, 0x39,
+       0x83, 0xee, 0x01, 0x2b, 0x46, 0x73, 0x08, 0xc6,
+       0x09, 0x61, 0xba, 0x53, 0x52, 0xed, 0xf2, 0x43,
+       0x9a, 0xfd, 0x47, 0xf4, 0x56, 0x73, 0x3f, 0xe6,
+       0x18, 0x77, 0x33, 0x2e, 0x6d, 0x5c, 0xf8, 0x5b,
+       0x5f, 0x87, 0x57, 0x82, 0x8d, 0xed, 0x6e, 0xb6,
+       0xa2, 0x97, 0x6c, 0xc2, 0xeb, 0x7e, 0x88, 0xc5,
+       0x51, 0xb8, 0x06, 0x62, 0x6d, 0x6b, 0xd8, 0x6e,
+       0xb9, 0x16, 0xfc, 0x1d, 0x15, 0x41, 0x97, 0x89,
+       0xbf, 0x2c, 0xfc, 0x85, 0x30, 0x6e, 0xc2, 0x5f,
+       0x26, 0xda, 0x99, 0xce, 0x8f, 0xcb, 0xca, 0xfe,
+       0x68, 0x4b, 0x3c, 0x5f, 0x26, 0x9a, 0x84, 0x06,
+       0xc9, 0xcd, 0xdf, 0xb0, 0xae, 0x38, 0x33, 0xda,
+       0xf0, 0x71, 0xd9, 0x94, 0xbf, 0xb3, 0xc1, 0xec,
+       0x3f, 0xda, 0xe0, 0x7c, 0x19, 0xb3, 0x48, 0xc3,
+       0x29, 0x57, 0x7d, 0x19, 0xe5, 0x14, 0xe8, 0xfe,
+       0x01, 0x18, 0xbd, 0x4b, 0xc1, 0x26, 0xa7, 0x46,
+       0xdf, 0x62, 0x2e, 0x96, 0xe0, 0xba, 0x97, 0xdf,
+       0xf7, 0xf7, 0xf6, 0x4e, 0x01, 0x3f, 0x5a, 0x44,
+       0xe8, 0x17, 0xc6, 0x89, 0x99, 0xd6, 0xa5, 0xe8,
+       0x37, 0x73, 0x4a, 0xf6, 0x96, 0x33, 0x79, 0x4b,
+       0xd7, 0x85, 0xdc, 0x01, 0x1e, 0x53, 0x29, 0xbb,
+       0x91, 0x52, 0x4f, 0x6f, 0x55, 0x7f, 0x96, 0x2c,
+       0x90, 0x8c, 0x80, 0xde, 0x68, 0xbb, 0x4d, 0x29,
+       0x6e, 0xa4, 0x38, 0x7f, 0x53, 0x29, 0x9b, 0x30,
+       0xef, 0x24, 0xb5, 0x14, 0x21, 0x5a, 0x8a, 0x1d,
+       0x29, 0xf7, 0x0e, 0x2b, 0x65, 0x49, 0xb4, 0x0c,
+       0x27, 0x95, 0x81, 0x70, 0x4b, 0x65, 0x3b, 0xe3,
+       0x3f, 0xf8, 0x2e, 0x36, 0xce, 0xd8, 0x9f, 0x3d,
+       0x3d, 0x8c, 0x7f, 0xde, 0x97, 0x72, 0x5f, 0x34,
+       0x8c, 0xbb, 0x55, 0xe3, 0xde, 0xf7, 0x2c, 0x7b,
+       0x97, 0x21, 0x44, 0xe7, 0x0b, 0xc3, 0x6a, 0xc6,
+       0x3f, 0x3f, 0xca, 0x1f, 0xb5, 0x0d, 0x73, 0xa6,
+       0x6a, 0x25, 0x68, 0x2b, 0x29, 0x25, 0xcb, 0xaf,
+       0x7e, 0x3b, 0x83, 0x7b, 0x9d, 0xec, 0xab, 0xcb,
+       0xb5, 0x6a, 0xa9, 0x79, 0xd1, 0x52, 0xd1, 0x13,
+       0xb9, 0x76, 0x41, 0x2b, 0xf5, 0x2b, 0xf3, 0xa6,
+       0x60, 0xdf, 0xaf, 0xbb, 0x5d, 0xaa, 0x5f, 0x27,
+       0xb6, 0x0c, 0xf3, 0x05, 0x36, 0xd0, 0x0c, 0x80,
+       0xb5, 0xb6, 0xb0, 0xfb, 0x45, 0xe4, 0x6d, 0xd1,
+       0x6e, 0xf4, 0xa7, 0xf9, 0x9c, 0xf6, 0xc7, 0x6b,
+       0x18, 0x5e, 0x81, 0xf0, 0x72, 0x34, 0x35, 0x5e,
+       0xd7, 0xcd, 0x9f, 0xf7, 0x94, 0x9b, 0xfd, 0x11,
+       0x31, 0x55, 0xd7, 0xfd, 0x25, 0xa5, 0x98, 0x75,
+       0x68, 0x39, 0x45, 0xbd, 0x5f, 0x47, 0x6f, 0x71,
+       0x30, 0x1d, 0x7d, 0x05, 0x7f, 0xc7, 0xf0, 0x77,
+       0x0d, 0x7f, 0x57, 0xf1, 0xd7, 0xab, 0xea, 0x68,
+       0xd6, 0x30, 0xcd, 0x33, 0xa3, 0xe6, 0xa1, 0xdc,
+       0x98, 0xee, 0x5d, 0xbf, 0x9d, 0x96, 0x9e, 0x0d,
+       0x49, 0xf9, 0xa4, 0x19, 0x1f, 0x97, 0xb9, 0x58,
+       0x8e, 0x3c, 0x5d, 0xce, 0xfd, 0x74, 0x82, 0x7e,
+       0xcc, 0x71, 0x6f, 0x48, 0x31, 0x63, 0xdd, 0x46,
+       0xaa, 0xfe, 0x6f, 0x2c, 0xdd, 0x71, 0x1a, 0x9e,
+       0x57, 0xa0, 0xb3, 0x44, 0xb6, 0xe9, 0x5f, 0x0a,
+       0x8e, 0xfa, 0xf1, 0x49, 0x85, 0x66, 0xfe, 0x7e,
+       0x1e, 0xf7, 0x6e, 0x96, 0x07, 0xc6, 0x97, 0xd3,
+       0x4a, 0x2b, 0xce, 0xc8, 0xbf, 0x05, 0xdf, 0xf5,
+       0x03, 0x30, 0x37, 0xdb, 0xa8, 0x1c, 0xce, 0xdd,
+       0x30, 0x6f, 0x38, 0x77, 0xe0, 0x73, 0x38, 0x48,
+       0xaf, 0xdc, 0x4c, 0x69, 0xcc, 0xbb, 0x95, 0x92,
+       0xfe, 0x69, 0xef, 0xe6, 0x15, 0xb1, 0xb7, 0xff,
+       0x53, 0x47, 0x2b, 0xc6, 0x54, 0x97, 0xd8, 0xc7,
+       0xdf, 0x0c, 0xa7, 0x53, 0xef, 0x75, 0x93, 0x50,
+       0x63, 0xf4, 0x52, 0x3e, 0x3f, 0x3b, 0x9f, 0x9d,
+       0x20, 0x41, 0x29, 0x3a, 0xe6, 0x1b, 0x53, 0x4a,
+       0x8a, 0x46, 0xeb, 0xd7, 0xce, 0xb5, 0x37, 0xd2,
+       0x1d, 0x72, 0xbe, 0x12, 0xe9, 0x00, 0x9e, 0x4a,
+       0x67, 0x4d, 0xe8, 0x5f, 0xb1, 0x6e, 0xf0, 0x15,
+       0x57, 0x97, 0x2b, 0xf1, 0xbe, 0x75, 0xec, 0x19,
+       0x8a, 0x0d, 0xf5, 0xee, 0x55, 0xf1, 0xc3, 0xcc,
+       0x0c, 0xd8, 0x20, 0x64, 0x00, 0x9d, 0x8a, 0xf6,
+       0x62, 0x30, 0xd2, 0xb5, 0x96, 0x4e, 0xd6, 0x41,
+       0xea, 0x0e, 0xeb, 0x06, 0xfa, 0xfe, 0x22, 0x9d,
+       0x08, 0x8c, 0xa9, 0xe1, 0xb3, 0x9d, 0xe8, 0x21,
+       0xa3, 0x91, 0x94, 0xfd, 0x25, 0x17, 0x61, 0xde,
+       0x8f, 0x06, 0xc8, 0x6a, 0x36, 0x37, 0xa7, 0xae,
+       0x4f, 0xf5, 0xba, 0x9f, 0x2b, 0xe9, 0x81, 0xb4,
+       0x99, 0x17, 0x21, 0xa9, 0xec, 0x22, 0xe4, 0xbb,
+       0xbf, 0x17, 0x84, 0xc4, 0xe4, 0xa4, 0x03, 0xf6,
+       0x03, 0xa2, 0xc5, 0x96, 0x6c, 0x0f, 0x4b, 0x70,
+       0x76, 0x6c, 0x12, 0x9d, 0x34, 0x71, 0x0d, 0xb9,
+       0xbc, 0x14, 0x3e, 0x44, 0x27, 0x38, 0xa4, 0x65,
+       0xc0, 0x0e, 0x9f, 0xfb, 0xe0, 0xa1, 0x4d, 0xa1,
+       0x09, 0x6e, 0x30, 0xe7, 0xba, 0xc0, 0x36, 0xa1,
+       0x83, 0x7f, 0xe1, 0x80, 0x6a, 0xdb, 0x85, 0xd2,
+       0xd2, 0xdd, 0x98, 0x50, 0x05, 0x6a, 0x5b, 0xe9,
+       0x9b, 0xe1, 0x32, 0x44, 0x64, 0xf5, 0x64, 0xa4,
+       0xaf, 0xb8, 0x33, 0xc3, 0xee, 0x7f, 0xa1, 0x04,
+       0x70, 0xf5, 0xc3, 0xbe, 0x5b, 0x56, 0x6e, 0x4f,
+       0x5f, 0x15, 0x39, 0x3a, 0xc4, 0xa7, 0xa8, 0x62,
+       0x3e, 0x05, 0xc0, 0x16, 0xba, 0x77, 0xf2, 0x77,
+       0xbb, 0xbc, 0xb9, 0x00, 0x4b, 0x7b, 0x2e, 0xc6,
+       0x1d, 0x28, 0x04, 0xdb, 0xda, 0x42, 0xd8, 0xca,
+       0xb0, 0x3b, 0xef, 0x5c, 0x03, 0xc0, 0x42, 0xbb,
+       0xef, 0xdc, 0x07, 0x97, 0xc9, 0xdb, 0x84, 0x0f,
+       0x64, 0x99, 0xe7, 0xb0, 0x61, 0x0e, 0x66, 0x71,
+       0xe7, 0xd1, 0x9b, 0x52, 0x0c, 0xf7, 0x52, 0xd1,
+       0x1f, 0x90, 0x1e, 0xd7, 0xfc, 0x39, 0xa3, 0xcf,
+       0x2e, 0x70, 0xec, 0x27, 0x4f, 0x89, 0xde, 0x88,
+       0xca, 0xd9, 0x01, 0xfa, 0x5c, 0xf6, 0x96, 0x14,
+       0x5e, 0xad, 0x60, 0x0c, 0x80, 0x23, 0x03, 0x96,
+       0x63, 0x5e, 0xb3, 0xa2, 0x4f, 0x00, 0x6c, 0xb3,
+       0xe9, 0x26, 0x8e, 0x46, 0x36, 0x2e, 0x22, 0x15,
+       0x67, 0x46, 0x98, 0xb8, 0x9f, 0xef, 0x7d, 0x03,
+       0xd3, 0xb7, 0xca, 0x76, 0x46, 0xb7, 0x87, 0xd5,
+       0xb5, 0x7f, 0x30, 0x8f, 0x38, 0x55, 0x58, 0x75,
+       0xe3, 0x9a, 0xcd, 0xb6, 0xa4, 0x8f, 0x7f, 0x43,
+       0x41, 0xb6, 0x0e, 0x49, 0x1b, 0xeb, 0xfc, 0x84,
+       0xee, 0x1d, 0x0d, 0x62, 0x6c, 0x36, 0x3d, 0x80,
+       0x21, 0x54, 0x08, 0x1d, 0xb6, 0x50, 0xe9, 0x99,
+       0xc1, 0x7b, 0x71, 0x6a, 0x19, 0x39, 0xb7, 0xc8,
+       0x28, 0xc8, 0x4b, 0xa5, 0xbc, 0x4b, 0xf4, 0x62,
+       0xcf, 0xcd, 0xad, 0x17, 0x2b, 0x6e, 0xc9, 0xe1,
+       0xc6, 0xfa, 0x34, 0x60, 0x7d, 0xae, 0xfc, 0xe5,
+       0xf5, 0xa1, 0x9d, 0xf6, 0x54, 0x23, 0x6a, 0x3d,
+       0xaf, 0xd9, 0xad, 0x3d, 0xe9, 0x9d, 0x83, 0x7a,
+       0xd9, 0x93, 0xbe, 0xea, 0x8b, 0x81, 0x3c, 0xb5,
+       0xef, 0x04, 0x58, 0x7a, 0x6d, 0xb0, 0xef, 0xf2,
+       0x26, 0x82, 0xfe, 0xe0, 0x45, 0x9c, 0x19, 0xdc,
+       0x48, 0x17, 0x0e, 0x1d, 0xe8, 0x9a, 0x83, 0x5e,
+       0xde, 0x1e, 0x46, 0xfb, 0xda, 0x9d, 0xf4, 0xb6,
+       0xb4, 0x87, 0x85, 0xbb, 0x28, 0xec, 0x76, 0x7a,
+       0x9c, 0x21, 0xa4, 0x45, 0x4f, 0x67, 0xd4, 0x5a,
+       0xf0, 0x38, 0xbb, 0x9a, 0xc0, 0x48, 0x27, 0x01,
+       0xf9, 0x80, 0xd1, 0xbc, 0x4a, 0x34, 0x79, 0xaa,
+       0x2e, 0xa8, 0xa1, 0x57, 0x50, 0x17, 0x74, 0x6a,
+       0x98, 0xf4, 0x42, 0xa0, 0x6f, 0x24, 0xdf, 0x58,
+       0x78, 0x93, 0x5c, 0x4a, 0x87, 0x69, 0xc4, 0x28,
+       0xc7, 0xfb, 0x5f, 0xfd, 0x0f, 0x75, 0xe5, 0xc3,
+       0xaf, 0xd6, 0x82, 0x2f, 0x91, 0xc3, 0xf5, 0xf4,
+       0x55, 0x03, 0xd7, 0xbe, 0x5a, 0x0e, 0xa1, 0x03,
+       0x4c, 0x12, 0x47, 0x99, 0x1c, 0x0e, 0xfd, 0x45,
+       0x72, 0xd8, 0xfc, 0x17, 0xc8, 0xc1, 0x21, 0x0c,
+       0xe9, 0xd5, 0xa5, 0xd7, 0xb8, 0x76, 0xb0, 0x53,
+       0x21, 0x7a, 0x86, 0xcb, 0x22, 0x67, 0xf3, 0x57,
+       0xff, 0x23, 0x59, 0xe0, 0xea, 0xc0, 0x7c, 0x93,
+       0x3c, 0x2c, 0x78, 0x8d, 0x95, 0x2f, 0x0d, 0x97,
+       0x8a, 0xbf, 0xf7, 0x16, 0xa9, 0x60, 0x5b, 0x75,
+       0x7a, 0x26, 0x9b, 0x81, 0xf4, 0x55, 0x7f, 0x3a,
+       0x99, 0xaf, 0xca, 0xc6, 0x31, 0x4c, 0x36, 0xf9,
+       0x28, 0x9b, 0x43, 0xa4, 0x23, 0x45, 0x48, 0x77,
+       0x22, 0xf4, 0x16, 0x93, 0xcd, 0xd1, 0x7c, 0x55,
+       0x36, 0x0e, 0x94, 0x4d, 0xbe, 0x2a, 0x1b, 0xc7,
+       0x97, 0xc9, 0xe6, 0x45, 0x1f, 0xe4, 0xab, 0xb2,
+       0x71, 0xf0, 0x10, 0xca, 0x46, 0x0d, 0xbd, 0x72,
+       0xe7, 0x5a, 0x07, 0xf8, 0x1d, 0xf9, 0x5c, 0x36,
+       0x98, 0x5e, 0xed, 0xbe, 0x45, 0x36, 0x8b, 0xb8,
+       0x6c, 0xd2, 0xc4, 0x9b, 0xa4, 0xb3, 0xe5, 0xab,
+       0xff, 0x71, 0xe9, 0xfc, 0xe9, 0x12, 0xda, 0xd1,
+       0xd7, 0xbe, 0x5a, 0x42, 0xa3, 0xd8, 0xfe, 0x9c,
+       0x27, 0xfb, 0xd8, 0x9d, 0x9d, 0xb8, 0x2c, 0x7d,
+       0xa6, 0x8e, 0xee, 0x9b, 0xfe, 0xcb, 0x62, 0xef,
+       0x73, 0x8a, 0x8d, 0x85, 0x76, 0x60, 0xc8, 0x84,
+       0xd4, 0xa0, 0xc3, 0x59, 0xdc, 0x7a, 0x92, 0xde,
+       0x89, 0xd6, 0x5d, 0x4a, 0x77, 0xa6, 0x92, 0x2d,
+       0x36, 0xba, 0xbf, 0x0f, 0x76, 0xfc, 0xd9, 0xdc,
+       0x13, 0xa1, 0x10, 0x7f, 0xd3, 0x24, 0x88, 0xdf,
+       0x47, 0xe7, 0xce, 0x70, 0xbb, 0x2c, 0x4c, 0x04,
+       0x23, 0x7d, 0x09, 0xc8, 0x3e, 0x20, 0x41, 0x42,
+       0x92, 0xca, 0xe5, 0x35, 0xef, 0xb7, 0x97, 0x80,
+       0x2e, 0x0f, 0x73, 0x25, 0x4a, 0x30, 0x6a, 0xcb,
+       0x92, 0x78, 0x9c, 0xe3, 0xcc, 0xcc, 0x0f, 0xa0,
+       0xd4, 0x0d, 0x68, 0xef, 0xcd, 0xf8, 0xb3, 0x22,
+       0xa7, 0x5d, 0x99, 0x06, 0x77, 0x8c, 0xca, 0x89,
+       0xce, 0x6f, 0x9a, 0xe7, 0x8d, 0x91, 0x2d, 0x5d,
+       0xdf, 0x07, 0x73, 0xbd, 0xb1, 0xea, 0xed, 0x4c,
+       0x03, 0xe3, 0xbc, 0x5d, 0x82, 0xd1, 0xfb, 0x94,
+       0x04, 0x2c, 0xc9, 0x2c, 0x81, 0x6d, 0x21, 0xc6,
+       0xa6, 0x33, 0x3e, 0x1e, 0xf4, 0xc6, 0xbb, 0x90,
+       0x47, 0x9f, 0x9c, 0xac, 0xa6, 0x4d, 0xc7, 0x34,
+       0xf2, 0x98, 0xe2, 0xa2, 0x65, 0xa5, 0x39, 0x0a,
+       0x75, 0xbd, 0xe2, 0x8b, 0xde, 0x18, 0xc5, 0xba,
+       0xef, 0x29, 0xc5, 0x2c, 0x98, 0x18, 0x47, 0x3a,
+       0x2f, 0x19, 0x40, 0xa7, 0x1b, 0x50, 0x2c, 0xf4,
+       0xac, 0x1c, 0xcb, 0x33, 0xd2, 0xdb, 0x58, 0xf1,
+       0xe9, 0x99, 0x58, 0x87, 0xf1, 0xdf, 0x27, 0x21,
+       0x8a, 0x96, 0xcc, 0x0c, 0x5d, 0xef, 0xf8, 0x26,
+       0x30, 0xeb, 0x7a, 0xb5, 0x19, 0xc8, 0xd6, 0x8f,
+       0x3e, 0x3d, 0xdc, 0x95, 0xc7, 0xbf, 0xd3, 0xe2,
+       0x7f, 0xd2, 0xfd, 0x82, 0x7a, 0x36, 0x12, 0xcd,
+       0x48, 0x34, 0x7b, 0xea, 0x89, 0x1e, 0x8c, 0x65,
+       0x58, 0x2f, 0x17, 0x9d, 0xa0, 0x14, 0x9b, 0x71,
+       0x72, 0x90, 0x02, 0xd3, 0x8c, 0xba, 0x6b, 0xe3,
+       0xe9, 0xcd, 0xd1, 0x2f, 0x74, 0x03, 0xe3, 0x4b,
+       0x75, 0xbd, 0xc8, 0x71, 0x07, 0xaf, 0xb9, 0xfd,
+       0x2c, 0x86, 0x17, 0x8b, 0x01, 0x09, 0x46, 0x6e,
+       0x1f, 0x94, 0x06, 0xbb, 0x9b, 0x15, 0xab, 0xb6,
+       0xa5, 0x56, 0x02, 0xda, 0x21, 0x67, 0xdb, 0xa9,
+       0x90, 0x3d, 0xf0, 0xf2, 0xb6, 0x8f, 0x1c, 0x50,
+       0x4c, 0xac, 0x85, 0x47, 0x78, 0x2e, 0x4d, 0xb2,
+       0x13, 0x16, 0xeb, 0x8a, 0x21, 0x91, 0xbd, 0x9b,
+       0x8b, 0x65, 0x29, 0xc9, 0xf4, 0x2d, 0x58, 0xd6,
+       0x66, 0x3d, 0xc6, 0x86, 0x72, 0xd5, 0x0b, 0x71,
+       0xe4, 0x31, 0xb8, 0x9f, 0xa3, 0x53, 0x2a, 0xbc,
+       0x21, 0xae, 0x27, 0xde, 0x35, 0x4a, 0x71, 0xaa,
+       0x2b, 0x7d, 0x0e, 0xf5, 0xb2, 0x17, 0x7b, 0x5d,
+       0xc9, 0xc4, 0x5e, 0x3c, 0xa2, 0xb6, 0x93, 0xd5,
+       0xf7, 0xce, 0x78, 0x6c, 0x4d, 0xa2, 0xae, 0xd8,
+       0xbb, 0x03, 0xe7, 0x2e, 0xd3, 0xf8, 0xc5, 0xba,
+       0x3c, 0xf2, 0x67, 0x46, 0x9d, 0xc2, 0x96, 0x24,
+       0xe1, 0x6f, 0x6d, 0xe5, 0x2b, 0x60, 0x75, 0x3f,
+       0x47, 0x36, 0x9c, 0xce, 0xbe, 0x20, 0x9e, 0x1a,
+       0xbf, 0x8c, 0x89, 0x90, 0xb8, 0x19, 0x35, 0x6a,
+       0xf7, 0xd3, 0xad, 0xfa, 0x74, 0xa3, 0xf7, 0x29,
+       0xd4, 0x34, 0x4b, 0x86, 0x1b, 0xb9, 0x46, 0xe7,
+       0xf9, 0xa4, 0x9d, 0xc8, 0xe9, 0x28, 0xfa, 0x18,
+       0x57, 0x11, 0x6b, 0xdf, 0x80, 0x9a, 0x47, 0xa7,
+       0x35, 0x6d, 0x80, 0x65, 0x09, 0x42, 0x86, 0xae,
+       0x8f, 0x5a, 0x67, 0xfa, 0x3e, 0xc5, 0xc1, 0x26,
+       0x1e, 0x46, 0x6e, 0x76, 0xe4, 0x66, 0x0b, 0xc4,
+       0x9d, 0x7b, 0xb5, 0xb8, 0xf8, 0x64, 0x07, 0xcc,
+       0xe4, 0x5c, 0x3e, 0xae, 0x10, 0x1c, 0x4e, 0xfb,
+       0xf9, 0x8a, 0x54, 0x4c, 0x3f, 0x80, 0xb9, 0x75,
+       0x11, 0xed, 0xdc, 0x9d, 0xa4, 0x9a, 0x49, 0xec,
+       0x7c, 0xef, 0x2d, 0x6b, 0xf6, 0x3e, 0xd5, 0xbc,
+       0x8a, 0x63, 0xdf, 0xdf, 0xff, 0xfc, 0xb7, 0xfe,
+       0x15, 0xeb, 0x54, 0x5d, 0x62, 0x3f, 0x89, 0x6b,
+       0xea, 0x81, 0xea, 0xe2, 0x25, 0xa9, 0x6a, 0x2f,
+       0xa8, 0x25, 0x62, 0xbe, 0x14, 0xac, 0x55, 0xbe,
+       0xbc, 0x68, 0xc5, 0x4c, 0xad, 0xf4, 0xe1, 0x25,
+       0xed, 0x66, 0xdf, 0x88, 0x5a, 0x96, 0x22, 0x54,
+       0x48, 0x70, 0x47, 0x6f, 0xd9, 0x65, 0x3d, 0x10,
+       0x1d, 0xce, 0x68, 0xf6, 0xe7, 0x59, 0x8a, 0xfc,
+       0x8a, 0x28, 0x68, 0x75, 0xb8, 0xa3, 0x3b, 0x00,
+       0x5a, 0xc9, 0xbf, 0xa2, 0x72, 0x8b, 0xb0, 0xdc,
+       0xf7, 0x22, 0x03, 0xaa, 0xb7, 0x86, 0xde, 0x00,
+       0x8d, 0xda, 0x41, 0xc9, 0x55, 0x5d, 0x84, 0x42,
+       0x2e, 0x3d, 0x3a, 0x6b, 0x6b, 0x03, 0x49, 0x2f,
+       0xd4, 0x9a, 0x4c, 0xdf, 0x6e, 0x91, 0xb2, 0xd4,
+       0xfb, 0x8c, 0xb6, 0x13, 0xa1, 0xe7, 0x43, 0xa4,
+       0x9d, 0x3a, 0x8f, 0x68, 0x44, 0x88, 0xbd, 0x10,
+       0x6f, 0xbf, 0x1d, 0xbf, 0x48, 0x5f, 0x86, 0x3b,
+       0x1d, 0x86, 0xca, 0xfb, 0x0e, 0x5c, 0x29, 0xc5,
+       0xd3, 0x5b, 0x86, 0xe6, 0xff, 0x13, 0xf2, 0x4e,
+       0x3c, 0x3f, 0x44, 0xde, 0x7c, 0xa5, 0x31, 0x4c,
+       0xe2, 0xb6, 0xd3, 0x24, 0xf1, 0xa8, 0x64, 0x4e,
+       0xde, 0x4e, 0xf6, 0x89, 0x5b, 0x51, 0xd3, 0xf7,
+       0xca, 0xf2, 0xd7, 0x92, 0xfd, 0xf3, 0x24, 0x7b,
+       0x2e, 0x73, 0xad, 0x07, 0x50, 0xf6, 0x93, 0xa2,
+       0xf5, 0xa9, 0xb9, 0x59, 0xf6, 0x58, 0x83, 0xf7,
+       0x86, 0xd4, 0x60, 0xde, 0xe0, 0x73, 0x85, 0x9b,
+       0x25, 0x45, 0x6f, 0xcf, 0x8d, 0xcc, 0x91, 0x41,
+       0x6f, 0xba, 0x49, 0x52, 0xab, 0xa8, 0xae, 0x32,
+       0xae, 0x46, 0x2c, 0xaf, 0x2d, 0x41, 0x3a, 0x53,
+       0xa7, 0x66, 0xef, 0xd0, 0x02, 0x9d, 0xe2, 0xb9,
+       0xc7, 0x3b, 0x75, 0x7d, 0xb4, 0x56, 0xb5, 0xee,
+       0x26, 0x8e, 0xc8, 0xeb, 0x8a, 0x30, 0x8e, 0xa7,
+       0x04, 0x9e, 0x74, 0x6f, 0xa6, 0x67, 0x37, 0x6a,
+       0xab, 0x99, 0x17, 0xce, 0xde, 0x4d, 0x25, 0xdb,
+       0x13, 0xb5, 0x17, 0x98, 0xb3, 0x03, 0x73, 0xed,
+       0x19, 0xd6, 0x1f, 0x10, 0xa9, 0xd3, 0x7a, 0x44,
+       0x30, 0xde, 0xdc, 0x27, 0xe1, 0x0e, 0x5d, 0x04,
+       0xe7, 0xb4, 0x53, 0x9a, 0x94, 0xb4, 0x16, 0x8e,
+       0xf1, 0x0d, 0xf6, 0xd2, 0xfb, 0xfb, 0x8b, 0xd7,
+       0x1c, 0x67, 0xb2, 0xda, 0xf9, 0x54, 0xab, 0x3e,
+       0xd5, 0xf0, 0x0b, 0xb4, 0xd8, 0xf8, 0xb3, 0x3f,
+       0xbf, 0x46, 0xd4, 0xa3, 0x5c, 0xde, 0x1d, 0x94,
+       0x4b, 0xe2, 0x74, 0x36, 0x56, 0xad, 0xd8, 0x3f,
+       0xd8, 0x8b, 0x12, 0xc4, 0x1d, 0x8c, 0xf6, 0x13,
+       0x6b, 0xcf, 0x08, 0x9c, 0x8b, 0x12, 0x71, 0xbd,
+       0x1e, 0xf3, 0xcc, 0x60, 0xdb, 0xe1, 0xc3, 0xe1,
+       0x6d, 0x1f, 0xb1, 0x97, 0xd3, 0x8e, 0xb9, 0xfa,
+       0x97, 0xb5, 0x7d, 0x68, 0x9b, 0x91, 0x4b, 0x10,
+       0x39, 0x74, 0xad, 0x98, 0x89, 0x75, 0x70, 0x2e,
+       0x11, 0x86, 0xd5, 0x01, 0xe7, 0x86, 0x31, 0xb8,
+       0x4e, 0x89, 0x31, 0x47, 0xeb, 0xb0, 0x90, 0xa7,
+       0xfb, 0xd0, 0x4e, 0x7d, 0x5c, 0x31, 0x3e, 0x44,
+       0x72, 0x10, 0x54, 0x7d, 0x69, 0xc5, 0xf5, 0xcf,
+       0x98, 0xc5, 0xb4, 0x0e, 0x1f, 0x53, 0x27, 0x30,
+       0x1d, 0xc5, 0x51, 0x65, 0xfb, 0x75, 0xf8, 0xf9,
+       0xd0, 0xfb, 0x28, 0x01, 0xfc, 0x25, 0xa2, 0x7c,
+       0x13, 0x50, 0x47, 0x12, 0x49, 0x4f, 0x86, 0x96,
+       0x63, 0xb9, 0x8a, 0x79, 0xb2, 0x34, 0x3d, 0xa1,
+       0x11, 0xea, 0x7d, 0x6a, 0x49, 0xca, 0x2e, 0xa4,
+       0x6a, 0xb6, 0x4d, 0xa0, 0x19, 0xc0, 0x4a, 0xf3,
+       0x25, 0xce, 0x9d, 0x76, 0xb1, 0x80, 0x5d, 0x73,
+       0xbc, 0x4f, 0xc9, 0x89, 0xde, 0xb5, 0x4b, 0x2c,
+       0x83, 0xa9, 0xbf, 0x44, 0x6a, 0x31, 0x19, 0x7b,
+       0x22, 0x71, 0xe3, 0xda, 0x9d, 0x94, 0x73, 0x48,
+       0xda, 0x04, 0x17, 0xd8, 0x49, 0xc3, 0x70, 0x5e,
+       0x4a, 0x6c, 0x35, 0x21, 0x3e, 0x11, 0xec, 0x5e,
+       0xa4, 0x59, 0xc2, 0xe6, 0xe2, 0xc1, 0x91, 0xcc,
+       0xe7, 0xf3, 0xaf, 0x98, 0xcd, 0x51, 0x63, 0x62,
+       0x2c, 0x6c, 0x36, 0x0f, 0xdc, 0x6e, 0x36, 0x47,
+       0x4d, 0xbd, 0x7a, 0xeb, 0x4c, 0x3e, 0x3a, 0x07,
+       0x5b, 0x48, 0xdf, 0xb0, 0x99, 0xce, 0xe7, 0xef,
+       0xd8, 0x53, 0x37, 0xcd, 0xdf, 0xe9, 0x83, 0xf3,
+       0xb7, 0xe9, 0xda, 0x9f, 0x9f, 0xbf, 0x6d, 0xe7,
+       0xb0, 0xa7, 0x06, 0xb4, 0xf9, 0xdb, 0xbc, 0x05,
+       0x63, 0xab, 0x89, 0x0f, 0x6a, 0x07, 0x9b, 0xc3,
+       0x62, 0x0b, 0xb4, 0xf9, 0xdb, 0xbc, 0x1a, 0xd3,
+       0xea, 0x86, 0xce, 0xdf, 0xb0, 0xf7, 0x76, 0xf3,
+       0xb7, 0x6d, 0xc3, 0xed, 0xe7, 0x6f, 0x93, 0xfc,
+       0xd5, 0xf3, 0x77, 0xdc, 0x54, 0xb2, 0x90, 0xa3,
+       0x83, 0xff, 0xb1, 0xf9, 0x9b, 0xcf, 0xa2, 0x7c,
+       0xfe, 0x36, 0xf7, 0xf0, 0x9a, 0x8f, 0x16, 0x30,
+       0xbc, 0x03, 0x61, 0x27, 0xce, 0x7c, 0x66, 0x3e,
+       0xfb, 0x0d, 0xda, 0x11, 0xde, 0x4f, 0x82, 0x8b,
+       0xbe, 0xfe, 0x35, 0xb7, 0xf3, 0xf5, 0xfd, 0xcb,
+       0xec, 0x56, 0x3b, 0x4c, 0x51, 0xac, 0x43, 0xbf,
+       0x03, 0x86, 0x3f, 0xc9, 0x6d, 0x1f, 0xd2, 0x97,
+       0xf1, 0xd1, 0xbe, 0xa4, 0xf9, 0x7e, 0xac, 0x04,
+       0x06, 0x27, 0xed, 0xe9, 0xf6, 0x7c, 0x0e, 0x31,
+       0x88, 0xef, 0xc1, 0xb2, 0x52, 0xd2, 0x9d, 0xd4,
+       0x7b, 0x54, 0x9a, 0x56, 0x56, 0x48, 0x2d, 0x8b,
+       0xf0, 0x74, 0x17, 0x73, 0x66, 0xb7, 0x36, 0x7e,
+       0x47, 0x2d, 0x8a, 0xca, 0x2c, 0xe9, 0xae, 0x42,
+       0x98, 0x22, 0xd5, 0xc8, 0x29, 0x52, 0xba, 0x54,
+       0x29, 0x27, 0xa1, 0xed, 0xba, 0x26, 0x9f, 0x14,
+       0x13, 0x11, 0x3b, 0x55, 0x9a, 0x2e, 0x9b, 0x5c,
+       0xbf, 0x85, 0x24, 0x29, 0x99, 0x6c, 0xe9, 0x49,
+       0x3d, 0xf2, 0xd5, 0xa9, 0xbb, 0x00, 0xe8, 0xfc,
+       0x3a, 0xa3, 0xf6, 0xdc, 0x9f, 0xbe, 0x51, 0xf8,
+       0x7e, 0x58, 0x34, 0xdd, 0x25, 0x48, 0x56, 0xd9,
+       0xc8, 0xd7, 0xb7, 0xea, 0xfa, 0xd1, 0xfc, 0xc6,
+       0x00, 0x96, 0xbb, 0x56, 0xb6, 0x64, 0xec, 0xcb,
+       0xc2, 0x3f, 0x7f, 0x04, 0x7d, 0x50, 0xf4, 0x03,
+       0x6c, 0x98, 0xaa, 0xca, 0xe1, 0x7e, 0x30, 0x9f,
+       0xeb, 0xd4, 0xea, 0x15, 0x7f, 0x10, 0x35, 0xe0,
+       0x43, 0xae, 0xaf, 0xa0, 0xd7, 0x68, 0x68, 0x54,
+       0xed, 0xdc, 0x47, 0x92, 0x50, 0xcc, 0x0c, 0xee,
+       0x90, 0x4b, 0x35, 0x0f, 0x62, 0xa8, 0x1f, 0x12,
+       0x8f, 0x96, 0x28, 0x76, 0x2b, 0xfa, 0x0a, 0x3d,
+       0xd8, 0x0a, 0xfa, 0x36, 0xd2, 0xcb, 0x12, 0x18,
+       0x45, 0xde, 0xdf, 0xae, 0x5e, 0x30, 0xbe, 0x3e,
+       0x00, 0xdb, 0x5e, 0xf7, 0xd0, 0x59, 0x97, 0x82,
+       0x5d, 0xa1, 0x3b, 0x49, 0xeb, 0x06, 0x7b, 0xa1,
+       0xd9, 0x28, 0xb8, 0xc4, 0x84, 0x2f, 0xeb, 0x89,
+       0x2f, 0x1b, 0x53, 0x10, 0xc2, 0x39, 0x76, 0x37,
+       0xf6, 0xc4, 0xf2, 0xd4, 0x50, 0x56, 0x68, 0x0a,
+       0x8e, 0x28, 0xde, 0x0b, 0x34, 0xb6, 0x68, 0x04,
+       0x69, 0xba, 0x36, 0xf2, 0x32, 0xd6, 0xcc, 0x24,
+       0x57, 0x96, 0xf5, 0x80, 0x3d, 0x30, 0x53, 0x48,
+       0x91, 0x2d, 0x74, 0x0f, 0x97, 0x7c, 0x22, 0xd1,
+       0x49, 0xe3, 0x47, 0x6b, 0xff, 0x48, 0x6c, 0xbf,
+       0xe9, 0x43, 0x39, 0x9d, 0x7b, 0x6c, 0x65, 0xa8,
+       0x75, 0x9a, 0xd7, 0x36, 0xef, 0x22, 0x4c, 0xa3,
+       0x11, 0xa2, 0x69, 0xa1, 0x10, 0x27, 0x9a, 0x30,
+       0x7f, 0x44, 0x34, 0xab, 0x73, 0xfe, 0x55, 0xcd,
+       0x12, 0x9c, 0x75, 0x06, 0x75, 0x12, 0x5c, 0x1b,
+       0x8b, 0xb5, 0x32, 0xa5, 0x3a, 0x25, 0x33, 0xe9,
+       0x1e, 0xdf, 0x2b, 0xa1, 0xe9, 0x5e, 0xd4, 0x7b,
+       0xc0, 0x11, 0x1e, 0xad, 0xa1, 0x17, 0x4b, 0x6e,
+       0x40, 0x99, 0x9d, 0x4a, 0x65, 0xb2, 0x34, 0x64,
+       0xec, 0xec, 0xc2, 0x11, 0x9c, 0xc2, 0xc6, 0x31,
+       0xc0, 0x41, 0x1a, 0x69, 0x23, 0xd3, 0x91, 0xc6,
+       0x49, 0x5f, 0x96, 0x61, 0xe3, 0xf0, 0xc3, 0x3c,
+       0x10, 0x74, 0xd1, 0x9a, 0x5b, 0x30, 0x2d, 0x8d,
+       0xbe, 0x17, 0xa5, 0x69, 0x16, 0xf3, 0x57, 0xe3,
+       0x55, 0xdb, 0xff, 0xb4, 0xe6, 0x6f, 0xca, 0x89,
+       0x2e, 0x94, 0x81, 0x7f, 0xa6, 0x77, 0xb3, 0x7c,
+       0x96, 0x9e, 0xe1, 0x6b, 0x77, 0x70, 0xb4, 0x71,
+       0x39, 0x1e, 0x57, 0x94, 0x34, 0x2e, 0x63, 0x5e,
+       0x40, 0x9e, 0x27, 0xa3, 0xb6, 0x08, 0x6b, 0x64,
+       0xc5, 0x11, 0x15, 0x73, 0x40, 0x2e, 0xe0, 0x31,
+       0xad, 0x5f, 0x53, 0x33, 0xc0, 0x8c, 0x23, 0xb4,
+       0x40, 0x34, 0x09, 0x69, 0x88, 0xf5, 0xd2, 0x9d,
+       0x67, 0x9a, 0x7f, 0x15, 0xac, 0x93, 0x75, 0x39,
+       0xe6, 0xd8, 0x20, 0xa3, 0x65, 0x37, 0xe6, 0x88,
+       0xdd, 0x18, 0x46, 0xfb, 0x35, 0xf2, 0x9a, 0x36,
+       0x3a, 0xc6, 0x69, 0x2b, 0x20, 0x5d, 0xfa, 0x4a,
+       0x1a, 0x43, 0x99, 0xb8, 0x6a, 0xfa, 0x97, 0xcb,
+       0xa4, 0xef, 0xac, 0x8f, 0x7b, 0xfd, 0xb1, 0xa9,
+       0x5c, 0xd2, 0x33, 0xbd, 0x36, 0x65, 0x05, 0x6a,
+       0xc6, 0x54, 0xf9, 0x7a, 0x75, 0xe7, 0x73, 0xef,
+       0x08, 0x66, 0x9a, 0xe7, 0x61, 0x6c, 0xab, 0xde,
+       0x3f, 0x96, 0x53, 0x0a, 0x65, 0x81, 0x58, 0x3e,
+       0x73, 0x25, 0x84, 0x85, 0x99, 0x39, 0x20, 0x9a,
+       0xe9, 0x2d, 0x8a, 0x9f, 0x79, 0x12, 0xd8, 0xde,
+       0x47, 0x5f, 0x67, 0x16, 0xeb, 0xdf, 0x7f, 0xe9,
+       0xe5, 0xe7, 0x77, 0x16, 0x61, 0x09, 0x19, 0x1e,
+       0x7f, 0xec, 0x1b, 0xdf, 0x91, 0xad, 0x24, 0x81,
+       0x4c, 0x1a, 0x01, 0xcf, 0x8a, 0x49, 0xc2, 0x18,
+       0x05, 0xb5, 0x47, 0xa4, 0xbd, 0xbf, 0x96, 0xa8,
+       0x75, 0x45, 0x3e, 0xba, 0x64, 0xb5, 0x87, 0x53,
+       0xac, 0x3f, 0xa0, 0x67, 0x10, 0x90, 0xa0, 0xd8,
+       0x59, 0xc8, 0x80, 0x21, 0xb2, 0xc5, 0xd6, 0xa8,
+       0x7d, 0xbc, 0xc4, 0xfa, 0x95, 0xea, 0x8b, 0x2b,
+       0x7a, 0xd2, 0x65, 0xf9, 0x5a, 0x75, 0xe7, 0xeb,
+       0xef, 0xc8, 0x93, 0x7c, 0xdf, 0x66, 0x67, 0x7f,
+       0xb2, 0x9e, 0x1a, 0x21, 0xa2, 0x3c, 0x56, 0x61,
+       0x4f, 0x6d, 0xcd, 0xa4, 0xb1, 0x7e, 0x54, 0x7d,
+       0xae, 0xc2, 0x39, 0xec, 0x78, 0xee, 0x9d, 0x34,
+       0xf3, 0x90, 0x56, 0xfd, 0x3d, 0xb5, 0xca, 0x76,
+       0x20, 0x75, 0x26, 0xfb, 0x1e, 0xe1, 0x91, 0xc8,
+       0x40, 0x56, 0x9c, 0xef, 0xdb, 0x83, 0x77, 0x0c,
+       0x47, 0xa0, 0x44, 0x8d, 0x59, 0xec, 0x5c, 0x4e,
+       0xcc, 0x61, 0xbb, 0x1f, 0xee, 0xc0, 0xfa, 0x1a,
+       0x79, 0x3a, 0x59, 0x5f, 0x25, 0x87, 0xa8, 0x2c,
+       0x57, 0x90, 0xca, 0x2c, 0x67, 0x71, 0xaa, 0x22,
+       0xf5, 0xf4, 0x4b, 0xdd, 0x63, 0xea, 0x6a, 0xa5,
+       0xdb, 0xfa, 0x06, 0xe9, 0x06, 0x6c, 0xdb, 0x65,
+       0x55, 0x20, 0x32, 0x7d, 0x48, 0x7d, 0xec, 0xd4,
+       0x16, 0xa6, 0x47, 0xda, 0x1c, 0x60, 0x12, 0x46,
+       0xa4, 0xc6, 0xa6, 0x99, 0xb0, 0x0f, 0xfb, 0x98,
+       0x7d, 0xe9, 0x1d, 0xb4, 0x70, 0x7e, 0xa0, 0x53,
+       0x4f, 0x51, 0xeb, 0xc7, 0x2e, 0x31, 0xd1, 0x29,
+       0xa8, 0xa2, 0x7a, 0xdf, 0xd3, 0xbd, 0x01, 0x53,
+       0x36, 0xde, 0xb7, 0x92, 0xc2, 0x88, 0x35, 0x79,
+       0x31, 0x4d, 0x39, 0x8f, 0xeb, 0x60, 0xb2, 0x65,
+       0x16, 0x3a, 0xdb, 0xd6, 0xbd, 0x65, 0xf8, 0x3f,
+       0xc2, 0x49, 0xc6, 0x34, 0x66, 0xdd, 0xce, 0xf6,
+       0xce, 0xbc, 0x04, 0x3a, 0xc1, 0xe5, 0xbf, 0x27,
+       0x18, 0xf1, 0xb9, 0x93, 0x4e, 0xce, 0xa7, 0x7d,
+       0x23, 0xfa, 0xe0, 0xd8, 0xc4, 0xb5, 0xc8, 0x81,
+       0x9f, 0x87, 0x14, 0x12, 0xe6, 0xd8, 0x32, 0xe0,
+       0x0e, 0x9a, 0x23, 0x24, 0x13, 0xbf, 0x6b, 0xed,
+       0xf9, 0xc4, 0x1f, 0x4e, 0x02, 0xb2, 0x8b, 0x79,
+       0xb8, 0xc6, 0xcf, 0xc1, 0xd0, 0x81, 0x01, 0x18,
+       0x69, 0xb3, 0xef, 0x2e, 0x04, 0x03, 0x7b, 0x73,
+       0xe9, 0x8f, 0x8a, 0x59, 0x4a, 0x25, 0x6f, 0xe3,
+       0xbd, 0xd4, 0xe3, 0xce, 0x03, 0x1d, 0xb1, 0x11,
+       0x94, 0xed, 0x87, 0x6b, 0x07, 0xc0, 0xe3, 0x71,
+       0x2d, 0x72, 0x39, 0x74, 0x1f, 0x7b, 0x2a, 0xce,
+       0x18, 0xd8, 0x3a, 0x5d, 0xc4, 0xe9, 0x3e, 0xb5,
+       0x70, 0xb5, 0xb8, 0x4a, 0x32, 0x87, 0x20, 0x56,
+       0xd1, 0x7b, 0x5c, 0x5d, 0xba, 0x65, 0x96, 0xb3,
+       0xdf, 0xe9, 0xd2, 0xb5, 0x18, 0xcd, 0x6b, 0x21,
+       0xc6, 0x86, 0x56, 0x19, 0xd8, 0x3d, 0x0f, 0x70,
+       0x16, 0xa9, 0x35, 0xd0, 0xb3, 0x1a, 0x9c, 0x0d,
+       0xdb, 0xee, 0xea, 0xb2, 0xcb, 0x42, 0x00, 0x12,
+       0x40, 0x4c, 0xb0, 0xdd, 0x25, 0xc1, 0x91, 0xdd,
+       0x89, 0x40, 0x9a, 0x79, 0xe4, 0xb5, 0x5d, 0x20,
+       0x9b, 0xb1, 0x67, 0x2f, 0x6b, 0xf7, 0x04, 0x0c,
+       0xb1, 0xdc, 0x77, 0xe1, 0x96, 0xe1, 0xc7, 0x9f,
+       0xd3, 0xc9, 0xb1, 0xca, 0x0a, 0xec, 0xa3, 0x73,
+       0xf4, 0x25, 0xf6, 0xdd, 0x89, 0xc3, 0xad, 0x74,
+       0xdc, 0xd8, 0x82, 0x42, 0x5d, 0xe1, 0xd4, 0x42,
+       0xdd, 0x56, 0x76, 0xe6, 0x10, 0xf6, 0xdc, 0x6e,
+       0xd2, 0xd3, 0xdd, 0xaa, 0x5e, 0x38, 0x9c, 0x30,
+       0x21, 0x8c, 0x38, 0xe6, 0x97, 0xef, 0x42, 0x7a,
+       0xf3, 0x15, 0xa9, 0xd0, 0x1b, 0x5a, 0xea, 0x90,
+       0xb3, 0x4c, 0xd8, 0xd3, 0xa3, 0xce, 0x12, 0x7d,
+       0x6d, 0xf1, 0x9e, 0x12, 0x59, 0x5b, 0x45, 0x3a,
+       0xaa, 0xd0, 0xba, 0x98, 0x0f, 0x23, 0xc7, 0x81,
+       0x15, 0x20, 0xee, 0x92, 0xe2, 0x91, 0x5a, 0xaf,
+       0x84, 0xbc, 0x21, 0xcd, 0xa6, 0xf9, 0x43, 0x8c,
+       0x57, 0xa2, 0xf0, 0x10, 0xe5, 0x4d, 0xc7, 0xda,
+       0xa4, 0xda, 0x65, 0x4b, 0x40, 0xe8, 0x5e, 0xd3,
+       0xf5, 0x54, 0xf3, 0x58, 0xd1, 0x16, 0x1c, 0x77,
+       0xee, 0x3b, 0x8d, 0xc9, 0xbe, 0x10, 0xc6, 0xe8,
+       0x3c, 0xc0, 0x6b, 0x64, 0xe9, 0x77, 0xdb, 0xe4,
+       0x53, 0xd8, 0x3e, 0x07, 0xda, 0xc8, 0xcc, 0x54,
+       0xd8, 0x48, 0xa7, 0xe1, 0xda, 0xd3, 0x74, 0x97,
+       0xd6, 0x73, 0x4e, 0x1f, 0xaf, 0x4f, 0x77, 0x64,
+       0x00, 0xf9, 0xbd, 0x30, 0xce, 0xf0, 0xd4, 0xf8,
+       0xa7, 0x32, 0x68, 0xa7, 0xcb, 0xb6, 0xdd, 0x29,
+       0x54, 0xa6, 0x2e, 0x5e, 0xdd, 0xab, 0xc4, 0xa4,
+       0x91, 0x05, 0x5c, 0x1e, 0xf2, 0xf4, 0x2c, 0xe0,
+       0xe5, 0xbf, 0x19, 0x5a, 0x96, 0x43, 0x67, 0xeb,
+       0x8d, 0x3a, 0xfb, 0x66, 0xa8, 0x39, 0x23, 0x35,
+       0xf6, 0x2b, 0x79, 0xbf, 0x45, 0xbc, 0x71, 0x64,
+       0x3d, 0x43, 0x4f, 0x9c, 0x32, 0x63, 0x9f, 0x19,
+       0x18, 0x75, 0xd6, 0x73, 0xe8, 0x76, 0x52, 0x8d,
+       0x3d, 0x8c, 0x14, 0xe7, 0xe4, 0xc5, 0xb7, 0xca,
+       0xd6, 0xbb, 0x4e, 0xc9, 0x18, 0x94, 0x5c, 0xf5,
+       0xba, 0xda, 0xe2, 0xbd, 0xc5, 0xf2, 0xa5, 0x41,
+       0x69, 0x63, 0xde, 0x67, 0x56, 0x00, 0x49, 0x4f,
+       0x3c, 0xf1, 0x65, 0x7d, 0x10, 0x4b, 0xef, 0xce,
+       0x3c, 0x2d, 0x5b, 0xd0, 0x8b, 0xad, 0xe2, 0x2d,
+       0x8d, 0x7a, 0x09, 0xbd, 0x74, 0x3f, 0x76, 0x77,
+       0x8a, 0x92, 0xea, 0x66, 0x90, 0xac, 0xe1, 0xee,
+       0x44, 0x6d, 0x6e, 0xc5, 0xbc, 0x0e, 0xd6, 0x6a,
+       0xea, 0x47, 0x0f, 0x1f, 0x35, 0x6c, 0xc7, 0x99,
+       0xc7, 0xbd, 0x03, 0x12, 0x03, 0xe0, 0x7f, 0xf2,
+       0x38, 0xdd, 0x99, 0x1b, 0x28, 0x5e, 0x83, 0x7e,
+       0x6a, 0xe2, 0x90, 0x1d, 0x69, 0x1e, 0xf7, 0x86,
+       0xa1, 0xa9, 0xa9, 0x6b, 0xa2, 0x69, 0xe8, 0x2f,
+       0x04, 0xc6, 0x75, 0x6f, 0xe6, 0xff, 0xd8, 0x7e,
+       0xec, 0x90, 0x62, 0xe1, 0x4f, 0xb6, 0xe8, 0xd9,
+       0x10, 0xdf, 0x81, 0x54, 0xf9, 0x8d, 0xff, 0xd8,
+       0x2e, 0xcc, 0xff, 0x84, 0xfc, 0x68, 0xab, 0x01,
+       0x0c, 0x7e, 0xf8, 0xeb, 0xdf, 0x5f, 0xff, 0xfe,
+       0xfa, 0xf7, 0xd7, 0xbf, 0xbf, 0xfe, 0xfd, 0xf5,
+       0xef, 0x6b, 0xed, 0xff, 0x0f, 0xab, 0x5e, 0xa9,
+       0x44, 0x5f, 0x39, 0xde, 0xb6, 0xa7, 0x20, 0xd5,
+       0xe5, 0xfd, 0x3e, 0x58, 0x97, 0xa6, 0xfe, 0xf8,
+       0x22, 0xa0, 0x17, 0xdf, 0x85, 0x61, 0x39, 0xc9,
+       0xdd, 0x04, 0xb6, 0xb4, 0x26, 0x30, 0x3a, 0x0a,
+       0x61, 0x86, 0x70, 0x4a, 0x38, 0xc5, 0x76, 0x5b,
+       0x67, 0xa6, 0x8e, 0x96, 0x8f, 0x4b, 0x35, 0x13,
+       0xca, 0xf9, 0x1d, 0x15, 0xf7, 0x44, 0x48, 0x60,
+       0x74, 0xb4, 0xae, 0xdf, 0xa8, 0x51, 0xa7, 0x9d,
+       0x4c, 0x63, 0x7b, 0xb3, 0x71, 0x2e, 0x66, 0xf3,
+       0xa9, 0xd3, 0x39, 0xac, 0x14, 0xab, 0xb5, 0xe9,
+       0xc9, 0x08, 0xd8, 0x14, 0xa3, 0x0f, 0x73, 0x22,
+       0xbf, 0x1e, 0xf4, 0x07, 0xf9, 0x8e, 0xfa, 0x2e,
+       0x7f, 0x64, 0x18, 0x65, 0xa0, 0x0b, 0x29, 0x5a,
+       0xe2, 0x97, 0x99, 0xbc, 0x58, 0x8e, 0x6c, 0x72,
+       0x4c, 0x04, 0x9b, 0x50, 0x86, 0x39, 0xce, 0xa6,
+       0x7a, 0x08, 0xa3, 0xf8, 0xe8, 0xfe, 0x56, 0x7a,
+       0x13, 0x98, 0x03, 0xba, 0x29, 0xb8, 0x56, 0xf4,
+       0x85, 0xd2, 0x58, 0xee, 0x34, 0xb7, 0xf7, 0x15,
+       0xcc, 0x9d, 0xde, 0x85, 0x57, 0x59, 0xf8, 0xf1,
+       0x25, 0x6c, 0x53, 0xb2, 0x77, 0x12, 0xd2, 0x27,
+       0xfa, 0xd6, 0xf8, 0x42, 0x53, 0x26, 0x81, 0xd1,
+       0x8d, 0x31, 0x4e, 0x2b, 0x1e, 0x4f, 0x4b, 0x90,
+       0x8f, 0x6d, 0x58, 0xa3, 0xde, 0x99, 0xb0, 0x57,
+       0x9c, 0x19, 0xc9, 0x77, 0xb4, 0x6b, 0x12, 0x82,
+       0xc8, 0xf0, 0xda, 0xa7, 0x33, 0x19, 0x09, 0x4c,
+       0x46, 0xc9, 0xd4, 0xf6, 0xaa, 0x8b, 0xc8, 0xeb,
+       0xa6, 0x96, 0x8b, 0x19, 0x58, 0xcb, 0x63, 0xb4,
+       0x3b, 0x53, 0x93, 0x14, 0x51, 0x0d, 0x95, 0xe8,
+       0xcd, 0x32, 0x0a, 0xf5, 0x0a, 0xbc, 0x14, 0x27,
+       0x2b, 0x25, 0x8d, 0xb5, 0xcf, 0x4e, 0x6d, 0x63,
+       0x2b, 0xa6, 0x26, 0xb6, 0x5a, 0xa7, 0x1a, 0x1a,
+       0xe9, 0x8e, 0x8d, 0x3f, 0x42, 0x3c, 0x85, 0xd1,
+       0x72, 0xb7, 0xe6, 0xef, 0x84, 0x68, 0x07, 0x29,
+       0xe6, 0x2f, 0x62, 0xdf, 0x4f, 0xc0, 0x12, 0x62,
+       0xd3, 0x3c, 0x69, 0x9d, 0xee, 0x0d, 0xe3, 0xcb,
+       0xb0, 0xb5, 0x3b, 0xc0, 0x3c, 0x9e, 0x9f, 0x00,
+       0x6a, 0x75, 0x2f, 0x06, 0x9b, 0x3b, 0x03, 0x6b,
+       0xec, 0xc1, 0x55, 0x6e, 0x62, 0xd1, 0x45, 0x3d,
+       0x60, 0x2d, 0x4e, 0x56, 0x9c, 0x89, 0xd5, 0x0d,
+       0xdf, 0x9b, 0x70, 0xbb, 0x2f, 0xf8, 0xfd, 0x7f,
+       0x8d, 0x93, 0xe0, 0xc0, 0x8d, 0xa5, 0xf0, 0x66,
+       0xaa, 0xa2, 0xf7, 0x03, 0x7d, 0xf7, 0xe2, 0x4d,
+       0x7b, 0x57, 0x87, 0xee, 0x5a, 0x33, 0xbc, 0x69,
+       0xa3, 0xef, 0x9e, 0x27, 0xbe, 0x4c, 0xd7, 0x49,
+       0x4b, 0x66, 0xb2, 0x2f, 0xa0, 0x3a, 0xee, 0xd7,
+       0xd1, 0x6d, 0xb5, 0x51, 0xf3, 0x50, 0x2a, 0x6f,
+       0xfd, 0x77, 0x0c, 0x8d, 0x60, 0xa1, 0x0d, 0x01,
+       0x33, 0x86, 0x8d, 0xb2, 0xf5, 0x62, 0x6d, 0xb8,
+       0x03, 0x62, 0x73, 0x40, 0xd6, 0x07, 0x74, 0xb9,
+       0xfb, 0x31, 0xa5, 0x79, 0x67, 0x07, 0x98, 0xe6,
+       0x13, 0xcd, 0x73, 0x98, 0xd7, 0x88, 0x54, 0x71,
+       0x0a, 0x7d, 0xf1, 0x0f, 0xe3, 0x15, 0x3f, 0x40,
+       0xcf, 0x6f, 0x63, 0xde, 0xfd, 0xba, 0x81, 0x83,
+       0x1d, 0x60, 0xd8, 0x45, 0x27, 0x7a, 0x5a, 0xf2,
+       0x0b, 0x21, 0xbc, 0xb3, 0xa8, 0x55, 0x9f, 0x63,
+       0xd8, 0xe8, 0xbc, 0x50, 0xe6, 0x73, 0x31, 0xac,
+       0xb1, 0xc6, 0x85, 0xab, 0x37, 0xb7, 0xa2, 0xf7,
+       0xb9, 0x2e, 0x96, 0xb1, 0x37, 0xa4, 0xfe, 0xbb,
+       0xa2, 0x3f, 0xee, 0x62, 0xfc, 0x9f, 0x67, 0x6f,
+       0xca, 0x6e, 0x7b, 0x6b, 0x73, 0xc5, 0x6f, 0x21,
+       0x02, 0x67, 0x3d, 0x9f, 0xe3, 0x75, 0xdb, 0x5b,
+       0x2d, 0x39, 0xf7, 0xeb, 0xcc, 0x58, 0xde, 0x00,
+       0xd6, 0xc6, 0xc0, 0xce, 0x27, 0x35, 0x56, 0x11,
+       0x0f, 0xa7, 0xa2, 0xaf, 0x75, 0xb1, 0xf7, 0xb3,
+       0x9e, 0xdf, 0xd0, 0xa1, 0x73, 0x5e, 0x70, 0x1e,
+       0x77, 0x32, 0x2e, 0xfb, 0x70, 0xa5, 0x8d, 0x3c,
+       0x5a, 0xcc, 0x1a, 0x37, 0x16, 0x7f, 0x9e, 0xc5,
+       0x9d, 0x14, 0x92, 0xc0, 0xe6, 0xcb, 0x1d, 0x78,
+       0xf2, 0x49, 0xfa, 0x36, 0x81, 0x90, 0x05, 0xc6,
+       0x73, 0x9d, 0x57, 0x3c, 0xec, 0x5c, 0xd5, 0xab,
+       0x15, 0x6a, 0x89, 0x9e, 0x2b, 0x54, 0x3e, 0xe3,
+       0xbd, 0x6f, 0x9a, 0x53, 0x67, 0xc6, 0x9f, 0x65,
+       0x5a, 0x07, 0x14, 0xc0, 0x46, 0xbc, 0x76, 0xc3,
+       0x26, 0xbc, 0x82, 0x4e, 0x8f, 0x57, 0xab, 0x6e,
+       0xc0, 0xfa, 0x10, 0xe8, 0xd8, 0x5e, 0x66, 0x33,
+       0xc3, 0x9e, 0x16, 0xed, 0xd1, 0xdd, 0xcd, 0x1a,
+       0xc6, 0x84, 0x50, 0xd0, 0x9d, 0x9e, 0xd6, 0x91,
+       0xb9, 0x06, 0x9e, 0x65, 0x5f, 0x3b, 0xc9, 0x3c,
+       0xce, 0xea, 0x18, 0xcd, 0x6b, 0xca, 0x2b, 0x84,
+       0x6b, 0xa2, 0x31, 0xaf, 0x50, 0x97, 0xb9, 0xd3,
+       0x8d, 0x12, 0xd3, 0xef, 0xec, 0xd0, 0xc1, 0x32,
+       0x63, 0x08, 0xaf, 0x98, 0xb2, 0xe6, 0x04, 0x6b,
+       0xc1, 0xae, 0x0e, 0xdd, 0xfe, 0x65, 0x44, 0xb3,
+       0x7f, 0x97, 0x9a, 0x2a, 0xc0, 0x47, 0x65, 0xf4,
+       0xfe, 0xdc, 0x5a, 0xf7, 0x34, 0x17, 0x6c, 0xc0,
+       0x5a, 0x9e, 0xa7, 0x7d, 0x9e, 0x3a, 0xb6, 0xe7,
+       0xe4, 0xad, 0x37, 0x73, 0xe0, 0x62, 0x59, 0xc8,
+       0x45, 0xfb, 0x80, 0xff, 0xde, 0x7c, 0xa0, 0x23,
+       0x02, 0x21, 0x17, 0x52, 0xb0, 0xfd, 0x1a, 0x6f,
+       0x35, 0x63, 0x7b, 0xcd, 0x68, 0x2d, 0x0a, 0xc1,
+       0x26, 0x1a, 0x3f, 0xf2, 0x5c, 0xf4, 0x84, 0x3a,
+       0x40, 0xc7, 0x7a, 0x63, 0x83, 0x82, 0x7c, 0xcd,
+       0x80, 0x94, 0xa8, 0x4b, 0xc6, 0x74, 0x09, 0xfe,
+       0x07, 0x3b, 0x03, 0xdf, 0x7b, 0xc2, 0x66, 0xeb,
+       0xca, 0x00, 0x1d, 0xbb, 0x57, 0x91, 0x88, 0xf1,
+       0x0f, 0x46, 0x57, 0x81, 0x4e, 0xb4, 0xb1, 0x7d,
+       0x9b, 0x1f, 0x2c, 0x81, 0x1b, 0x7b, 0xdc, 0x2c,
+       0x84, 0xab, 0x62, 0x51, 0x31, 0xd1, 0x69, 0x1f,
+       0xea, 0x0e, 0xce, 0x93, 0x18, 0x3e, 0xcb, 0x30,
+       0x1f, 0xc9, 0xec, 0xeb, 0x90, 0x0c, 0xf3, 0x36,
+       0xc3, 0x2c, 0x90, 0xcd, 0xb6, 0x7d, 0xf0, 0xa4,
+       0x08, 0x7a, 0x3a, 0xb7, 0xd2, 0x2a, 0xd3, 0xb7,
+       0x50, 0xcc, 0x54, 0x3b, 0xc5, 0xe4, 0x5b, 0xc9,
+       0x6a, 0x59, 0x08, 0x23, 0x18, 0x56, 0xc7, 0xb1,
+       0xd5, 0x1a, 0x76, 0x96, 0x5c, 0xc5, 0x6a, 0xfb,
+       0x3d, 0xc5, 0xca, 0x28, 0xb7, 0x70, 0xce, 0x81,
+       0x0c, 0x26, 0xd7, 0x7d, 0x9e, 0xfd, 0x6c, 0x8f,
+       0xfe, 0x49, 0xc5, 0xf4, 0x16, 0x69, 0xeb, 0xe6,
+       0x44, 0xa2, 0x7d, 0x96, 0xee, 0x59, 0xbc, 0xd5,
+       0xb2, 0x3c, 0xf6, 0x9c, 0xa5, 0xd1, 0xfa, 0x8b,
+       0xe7, 0x26, 0xd1, 0xfe, 0x95, 0xe2, 0xb9, 0xdf,
+       0x7a, 0xef, 0xb9, 0xda, 0xef, 0xcc, 0x79, 0x2f,
+       0x42, 0x5f, 0x00, 0xa9, 0x90, 0x6b, 0x55, 0xae,
+       0x89, 0x4c, 0x67, 0xb6, 0x28, 0x9e, 0xea, 0x7f,
+       0x17, 0xf7, 0xef, 0xdd, 0x8e, 0x7b, 0xa5, 0x9c,
+       0x1e, 0xd0, 0x7f, 0xcd, 0x9a, 0xcc, 0xbe, 0x3d,
+       0xed, 0x6d, 0xf9, 0xea, 0x96, 0xd1, 0x29, 0xaa,
+       0xe6, 0x16, 0x1b, 0xdd, 0x23, 0xa8, 0xd6, 0x19,
+       0xa8, 0x8e, 0xcf, 0x92, 0x5c, 0x11, 0xfb, 0xa0,
+       0x6c, 0xaa, 0x61, 0x75, 0xc6, 0x70, 0xbe, 0x6c,
+       0x9a, 0xab, 0x85, 0x0b, 0x64, 0x8b, 0x9b, 0x85,
+       0x55, 0x3a, 0x9b, 0x9c, 0x80, 0x52, 0xb6, 0x91,
+       0x96, 0x29, 0x66, 0xa3, 0x1a, 0x42, 0xfc, 0x68,
+       0xc2, 0x9b, 0x81, 0xe3, 0x4d, 0x83, 0x78, 0x21,
+       0xda, 0x2b, 0x9b, 0xd5, 0x5e, 0xd9, 0xcc, 0x4e,
+       0x25, 0xb5, 0xa9, 0xd4, 0x9b, 0xd5, 0x1e, 0x24,
+       0xec, 0x18, 0x39, 0x91, 0xb7, 0x21, 0xf5, 0xae,
+       0xa0, 0x29, 0x75, 0x3f, 0xdd, 0x7f, 0x52, 0x4b,
+       0x2d, 0x95, 0xe3, 0x19, 0xd5, 0x9b, 0xfa, 0x95,
+       0x30, 0x8a, 0x20, 0xe2, 0x1e, 0xa7, 0x53, 0x20,
+       0x63, 0xd6, 0x62, 0xe8, 0x5e, 0xd9, 0x54, 0xca,
+       0x34, 0x12, 0xc3, 0x09, 0x6a, 0xf8, 0x39, 0x0c,
+       0x57, 0xc9, 0x1e, 0x16, 0xfe, 0x9e, 0x9c, 0x9e,
+       0x43, 0x70, 0x4b, 0x8b, 0x66, 0x9f, 0x36, 0xf3,
+       0x72, 0xe8, 0xb4, 0xeb, 0xb7, 0x5e, 0x08, 0xc4,
+       0xa6, 0x9e, 0xa2, 0xfb, 0x5e, 0x62, 0x32, 0x6b,
+       0xe9, 0x96, 0xe1, 0x69, 0x69, 0xbf, 0xa6, 0x34,
+       0xe4, 0x96, 0x2b, 0xdb, 0x8b, 0xf8, 0xd7, 0x4e,
+       0x47, 0x83, 0x5e, 0x31, 0xba, 0x47, 0x8b, 0x66,
+       0xf7, 0x68, 0xf6, 0xc6, 0xe3, 0x58, 0x11, 0xfe,
+       0x74, 0x6e, 0xcc, 0x00, 0x30, 0x3b, 0x81, 0xe3,
+       0xca, 0x0c, 0x2f, 0xb0, 0x37, 0xe9, 0xe7, 0x71,
+       0x9c, 0x73, 0x16, 0xb3, 0x7c, 0xdf, 0x63, 0x1a,
+       0xb3, 0x91, 0x76, 0xe3, 0x19, 0x8f, 0x4e, 0xeb,
+       0xd0, 0x09, 0xf0, 0x3c, 0xb3, 0xb4, 0x03, 0xd3,
+       0x3a, 0xd6, 0x00, 0x3c, 0x4f, 0x33, 0xce, 0x9b,
+       0x37, 0x24, 0x08, 0xaf, 0xe7, 0xe5, 0xe7, 0xb1,
+       0xd1, 0x57, 0xed, 0x16, 0xee, 0xa2, 0x53, 0x6c,
+       0x0f, 0x3f, 0x46, 0x6f, 0xa6, 0x49, 0x0b, 0x51,
+       0x26, 0xbd, 0x18, 0xb2, 0x48, 0xf4, 0xd6, 0xd2,
+       0xb6, 0x9f, 0x8e, 0x41, 0xfa, 0x85, 0xec, 0xcb,
+       0x58, 0x28, 0x6d, 0x3a, 0x1b, 0xf0, 0xf0, 0x33,
+       0x0c, 0x7f, 0x2f, 0xe2, 0xd9, 0x5e, 0x93, 0xb7,
+       0x36, 0x33, 0xec, 0x72, 0x86, 0x7d, 0x10, 0xb1,
+       0x99, 0x7c, 0x54, 0x33, 0xac, 0x48, 0x77, 0x06,
+       0xde, 0xda, 0x54, 0x89, 0x57, 0xe1, 0x9a, 0xf6,
+       0xb6, 0x9f, 0x2d, 0x84, 0x33, 0x9a, 0x0e, 0x29,
+       0xf5, 0x74, 0xbf, 0xdf, 0xdd, 0x14, 0xf4, 0x37,
+       0x4b, 0x2d, 0x6d, 0xda, 0xd7, 0x03, 0x85, 0xa9,
+       0x82, 0x05, 0xaa, 0x9a, 0xea, 0x83, 0xed, 0x81,
+       0x46, 0xe1, 0x89, 0xa6, 0x86, 0xe0, 0x62, 0x01,
+       0x51, 0x51, 0xcc, 0xe2, 0xc6, 0x26, 0x65, 0x71,
+       0x70, 0x28, 0xa6, 0xa1, 0xd1, 0xaf, 0xd2, 0xe0,
+       0x9f, 0x2a, 0x01, 0xd0, 0x09, 0x12, 0xe8, 0xa7,
+       0x4b, 0x60, 0x48, 0x75, 0x5d, 0xd1, 0x09, 0x02,
+       0x3b, 0xc9, 0x9a, 0xae, 0xba, 0x2e, 0x7a, 0x16,
+       0xa7, 0xdb, 0x10, 0x88, 0x61, 0xef, 0x91, 0x0f,
+       0xb8, 0xfa, 0xc0, 0xa6, 0x6a, 0xb5, 0xc1, 0xaf,
+       0x0b, 0x40, 0xda, 0x5d, 0xf4, 0x46, 0x96, 0xcf,
+       0x45, 0x27, 0x98, 0x0a, 0x64, 0x31, 0xc3, 0x43,
+       0xf0, 0xc7, 0x38, 0x3e, 0x89, 0x8d, 0x05, 0xca,
+       0xe9, 0x87, 0x00, 0xac, 0x30, 0x04, 0xc7, 0x9c,
+       0x1b, 0xd1, 0xa0, 0x0f, 0x26, 0x48, 0x58, 0x2a,
+       0x52, 0x1c, 0x8d, 0xf4, 0xf2, 0x9c, 0xb7, 0xa4,
+       0xea, 0x87, 0xa5, 0x5a, 0x02, 0x10, 0xb4, 0x21,
+       0xd7, 0xcb, 0x7e, 0x6b, 0x80, 0xed, 0x6e, 0xa2,
+       0xd9, 0x00, 0x5e, 0x46, 0xbc, 0x2e, 0x38, 0x1a,
+       0x43, 0x27, 0x10, 0xaf, 0x63, 0xf8, 0xcd, 0xaa,
+       0x25, 0x30, 0xb1, 0xd8, 0x16, 0x4c, 0x0b, 0x21,
+       0x95, 0x3e, 0x38, 0x12, 0x43, 0xaf, 0x05, 0xc7,
+       0xa8, 0xb6, 0x52, 0x1f, 0x1c, 0x8d, 0x58, 0x03,
+       0xe2, 0xb6, 0xa8, 0xb8, 0xe7, 0x10, 0x17, 0x8f,
+       0x5c, 0x08, 0xb7, 0xce, 0x3f, 0x2a, 0xa0, 0xe7,
+       0x3d, 0x8e, 0xb1, 0x15, 0xfc, 0x2d, 0x8d, 0x74,
+       0xfd, 0x8a, 0xd8, 0x8b, 0xff, 0x90, 0x66, 0xa0,
+       0x77, 0x21, 0xa5, 0x3a, 0x9f, 0x13, 0x6b, 0x77,
+       0x55, 0x7b, 0x83, 0x82, 0xa5, 0x1a, 0x2e, 0x3e,
+       0x92, 0xc7, 0x53, 0x8b, 0x6f, 0x4d, 0x5d, 0x37,
+       0x60, 0xe8, 0xc9, 0x33, 0x48, 0x93, 0x7c, 0x4e,
+       0x77, 0x91, 0xa7, 0x68, 0xdd, 0x00, 0x34, 0x60,
+       0x2c, 0x25, 0x1a, 0xb3, 0x60, 0x2c, 0xde, 0xe7,
+       0xf4, 0x14, 0x21, 0x34, 0x45, 0xf3, 0x85, 0x3d,
+       0xf4, 0x0e, 0xb5, 0xf8, 0xfe, 0x7e, 0x92, 0xfa,
+       0xfe, 0x9c, 0x15, 0xc6, 0x7c, 0x38, 0x57, 0xde,
+       0xfd, 0x56, 0x52, 0xb6, 0x00, 0x7c, 0x67, 0xb9,
+       0x62, 0xee, 0x29, 0x3f, 0x50, 0x08, 0xbd, 0xa2,
+       0x11, 0xaf, 0xa3, 0xd6, 0x16, 0xd9, 0xd6, 0xa0,
+       0xe7, 0x63, 0x2b, 0xba, 0x08, 0x89, 0x58, 0xfe,
+       0xa9, 0x8a, 0x33, 0x06, 0xe4, 0x73, 0xd6, 0x19,
+       0x3e, 0x1b, 0xc2, 0x7f, 0xf8, 0x17, 0xc6, 0x7f,
+       0x67, 0xb7, 0x6e, 0x0d, 0xc1, 0x56, 0xa7, 0x20,
+       0x84, 0x42, 0x21, 0x61, 0x2b, 0xfe, 0x85, 0xb6,
+       0x86, 0x42, 0x1c, 0x77, 0x56, 0x44, 0x1a, 0x27,
+       0xd1, 0x85, 0xb6, 0x86, 0xc3, 0x5b, 0xcf, 0x12,
+       0x2e, 0x24, 0x38, 0x05, 0x24, 0x11, 0x38, 0xdd,
+       0x59, 0xa4, 0x23, 0x0a, 0xc6, 0x52, 0xd8, 0x4a,
+       0xfc, 0x30, 0xef, 0x59, 0x30, 0x3f, 0x44, 0xdf,
+       0x0d, 0x3a, 0xab, 0x63, 0x3e, 0xc6, 0x51, 0x73,
+       0x16, 0x7d, 0x9b, 0x85, 0x85, 0x7f, 0xb6, 0x8a,
+       0x6b, 0xd9, 0x31, 0x45, 0xbf, 0x4a, 0xe7, 0xc8,
+       0x02, 0x4b, 0x0e, 0x9c, 0x2d, 0xa3, 0x93, 0x68,
+       0xf3, 0x60, 0x13, 0x8d, 0xee, 0xc3, 0xe8, 0x5b,
+       0x3c, 0xb9, 0x2c, 0x05, 0x63, 0x38, 0x33, 0x72,
+       0xcc, 0xa5, 0xba, 0x5f, 0x12, 0x0c, 0xb3, 0xb7,
+       0xb4, 0x0f, 0x8b, 0x8e, 0x5d, 0x1d, 0x91, 0x35,
+       0x2d, 0x48, 0x71, 0xe2, 0xcb, 0x28, 0xe2, 0x87,
+       0xc7, 0xf3, 0x74, 0x8c, 0xea, 0x88, 0xca, 0x59,
+       0x17, 0xe5, 0x7c, 0x44, 0xa5, 0x3b, 0xc0, 0x6c,
+       0xce, 0x91, 0x28, 0x67, 0xdd, 0x89, 0x2f, 0xa3,
+       0x88, 0x1f, 0x1e, 0xa7, 0x2f, 0xc7, 0xf0, 0x37,
+       0xcf, 0xbd, 0xce, 0x25, 0x66, 0x37, 0x7f, 0x8f,
+       0x3c, 0x8c, 0x33, 0x72, 0xef, 0x32, 0x0b, 0xce,
+       0xc8, 0xbf, 0xe7, 0xf1, 0xa2, 0x3e, 0x50, 0xa9,
+       0x98, 0x06, 0x1d, 0x90, 0x92, 0x53, 0x49, 0x87,
+       0xbb, 0x86, 0xe2, 0xba, 0x3b, 0x20, 0x93, 0xde,
+       0x50, 0x40, 0xb8, 0xf2, 0x9c, 0xa7, 0x01, 0xed,
+       0xe0, 0x18, 0x27, 0xe8, 0x1c, 0x7a, 0xe2, 0xca,
+       0xac, 0xde, 0x81, 0x2e, 0xf2, 0x14, 0x88, 0x6b,
+       0x84, 0xbf, 0xad, 0x8e, 0x94, 0x93, 0x18, 0xce,
+       0xb8, 0xb6, 0x10, 0x8c, 0x09, 0x21, 0x8c, 0xdb,
+       0xa3, 0x71, 0x3d, 0xe6, 0x36, 0x8f, 0x71, 0x41,
+       0x1c, 0xbf, 0xfb, 0x87, 0x36, 0x2f, 0x4d, 0x67,
+       0xc4, 0xb1, 0xec, 0xc4, 0x51, 0x35, 0x8a, 0x8f,
+       0x5d, 0xf2, 0x64, 0xe0, 0xf9, 0x52, 0x3e, 0xe2,
+       0xd1, 0xaf, 0x09, 0x09, 0xdc, 0xc6, 0xbd, 0xd5,
+       0x4d, 0xf5, 0x45, 0xcf, 0xe6, 0x57, 0x82, 0x4d,
+       0x78, 0x3f, 0x35, 0xcc, 0xdf, 0x1d, 0x30, 0xf0,
+       0x7b, 0x80, 0xe6, 0xaf, 0xbb, 0xea, 0xd2, 0x39,
+       0x75, 0xff, 0xce, 0xf5, 0x9a, 0x23, 0xa4, 0xae,
+       0xdb, 0xfe, 0xba, 0x74, 0xfd, 0xbf, 0xe2, 0xef,
+       0xaf, 0xfd, 0xf5, 0x7f, 0xd7, 0x9f, 0xf6, 0x5d,
+       0xbd, 0xae, 0x16, 0xfa, 0x5a, 0xe6, 0xbf, 0x5c,
+       0x66, 0xd6, 0x78, 0x93, 0x1c, 0xef, 0xea, 0xa7,
+       0x19, 0xff, 0xc7, 0xaf, 0x72, 0x6f, 0x83, 0xaf,
+       0x31, 0xd5, 0xaf, 0x66, 0x46, 0x24, 0xf8, 0xe5,
+       0x63, 0x59, 0xa0, 0x80, 0xde, 0x9a, 0x3b, 0x80,
+       0xab, 0x53, 0xfe, 0x05, 0xf7, 0x6d, 0xef, 0x6e,
+       0xe5, 0xdf, 0x01, 0x47, 0x9b, 0x54, 0x71, 0xce,
+       0x53, 0xed, 0xcc, 0xd1, 0xf6, 0x63, 0x20, 0x8e,
+       0x7d, 0x71, 0x11, 0xe7, 0x64, 0xcf, 0x0e, 0x84,
+       0x05, 0xec, 0xea, 0xe1, 0x9e, 0xcd, 0x68, 0x27,
+       0x38, 0x53, 0x63, 0xd3, 0x0a, 0x89, 0x8a, 0xce,
+       0xda, 0x02, 0xda, 0xcb, 0xb0, 0x5b, 0x9d, 0x85,
+       0x1b, 0x78, 0x6e, 0x61, 0xa0, 0xc8, 0x35, 0x6b,
+       0x26, 0xf3, 0x3b, 0x8c, 0x74, 0x35, 0x83, 0x96,
+       0x63, 0xb9, 0x15, 0xa9, 0x3b, 0xb5, 0xd5, 0x85,
+       0x9c, 0xc7, 0x2c, 0x56, 0x0b, 0x9d, 0xec, 0x25,
+       0xd0, 0xba, 0x9f, 0xed, 0xdc, 0xc7, 0xab, 0x8d,
+       0x85, 0x13, 0xc1, 0x8a, 0x57, 0x3b, 0xd8, 0xf0,
+       0x9a, 0x02, 0x89, 0x9e, 0x1e, 0xac, 0x05, 0xed,
+       0xf7, 0xe1, 0xb3, 0xfb, 0x24, 0xe4, 0x62, 0x62,
+       0x5c, 0x84, 0x9b, 0xcb, 0x83, 0xd0, 0xb0, 0xf2,
+       0xec, 0xbc, 0x56, 0xaa, 0x67, 0xa6, 0xfb, 0xa8,
+       0x09, 0xe9, 0x67, 0xb9, 0xaa, 0xf2, 0x74, 0x6f,
+       0x0f, 0x60, 0xb9, 0x07, 0xa6, 0xc4, 0x92, 0x4c,
+       0xb7, 0xa4, 0xd0, 0x5b, 0xac, 0x2f, 0xa4, 0xac,
+       0x86, 0x6a, 0x5a, 0xcb, 0xe2, 0x4a, 0xed, 0xac,
+       0xe7, 0xa7, 0xce, 0x6e, 0x67, 0x5e, 0x36, 0x40,
+       0x7e, 0x0e, 0x40, 0xa1, 0xfe, 0x28, 0x7a, 0x02,
+       0x17, 0x2b, 0x1d, 0x06, 0xda, 0xa1, 0xfc, 0x8c,
+       0x73, 0xaa, 0xfe, 0x08, 0xce, 0x13, 0x2c, 0xd6,
+       0xdb, 0xe3, 0x59, 0xef, 0x2c, 0xd0, 0xf7, 0x54,
+       0x1c, 0x66, 0x98, 0xb3, 0x1e, 0xa2, 0xe8, 0x74,
+       0xda, 0x0e, 0xda, 0xde, 0xb6, 0x1d, 0xf2, 0xcd,
+       0x44, 0x0b, 0xdc, 0x95, 0x35, 0x4e, 0x18, 0x70,
+       0xcf, 0x2e, 0x5e, 0xa0, 0xc9, 0xf5, 0x82, 0x27,
+       0x4c, 0x2d, 0x6f, 0x0e, 0xef, 0x17, 0xc2, 0x51,
+       0x69, 0x9a, 0x9f, 0x5f, 0x2b, 0xc1, 0xaf, 0x96,
+       0x20, 0x8d, 0x83, 0xd1, 0x3c, 0xf3, 0xbd, 0x77,
+       0xab, 0x4b, 0xb8, 0x84, 0x0a, 0xb9, 0xb7, 0x5a,
+       0x9a, 0x66, 0x3f, 0xf1, 0x9d, 0xd4, 0xd8, 0x74,
+       0xf4, 0x2e, 0x7f, 0xe5, 0x9e, 0x73, 0x2c, 0x72,
+       0x15, 0x3d, 0x83, 0x8c, 0xe3, 0x44, 0xb1, 0x6f,
+       0xce, 0xcf, 0x22, 0x1f, 0xa4, 0xc6, 0x06, 0x8d,
+       0xcb, 0xb1, 0xb7, 0x4f, 0x1d, 0x16, 0x66, 0x0a,
+       0x19, 0xe8, 0x33, 0x84, 0x26, 0x84, 0x89, 0x73,
+       0x54, 0x1a, 0x94, 0xcf, 0x42, 0x5f, 0x49, 0xfd,
+       0xe5, 0x72, 0xee, 0x1b, 0x97, 0x0e, 0x08, 0xc0,
+       0x35, 0x66, 0xf0, 0x6b, 0xe5, 0x55, 0x43, 0x3f,
+       0x56, 0x0e, 0xa5, 0xb3, 0x7d, 0xb3, 0x48, 0xef,
+       0xca, 0x2a, 0xdc, 0xb3, 0x5c, 0x95, 0x95, 0xb3,
+       0x31, 0x98, 0x52, 0xda, 0xd4, 0x8c, 0xde, 0x69,
+       0xa0, 0x29, 0x18, 0x6c, 0x64, 0x1f, 0xae, 0xf6,
+       0xf8, 0x6a, 0x96, 0xb5, 0xb6, 0x08, 0xcb, 0x73,
+       0xb2, 0x72, 0x73, 0xdd, 0xb3, 0xe8, 0xf8, 0x51,
+       0xec, 0xbb, 0x61, 0x7f, 0x99, 0x99, 0xea, 0x99,
+       0x0d, 0x61, 0xf6, 0xb6, 0xc2, 0x78, 0xc5, 0x87,
+       0x1e, 0x7a, 0x1a, 0x7b, 0xb6, 0x8d, 0x32, 0x77,
+       0x14, 0xea, 0x21, 0x10, 0x8b, 0x2b, 0x5d, 0x53,
+       0xd1, 0x15, 0x5d, 0x28, 0x38, 0xce, 0xc1, 0x9e,
+       0x8d, 0x77, 0xe3, 0xaa, 0x1a, 0x65, 0x47, 0x4f,
+       0xe6, 0xb0, 0x77, 0xfc, 0x5f, 0x41, 0xc1, 0xe7,
+       0x47, 0xed, 0xb9, 0x6b, 0xb4, 0x8c, 0x9a, 0xdb,
+       0xe5, 0x44, 0x2d, 0xbf, 0x89, 0xf7, 0xad, 0xe5,
+       0x0f, 0xa7, 0xa1, 0xf7, 0xc2, 0xff, 0xde, 0xac,
+       0xb3, 0xb2, 0x7b, 0x08, 0x26, 0x5e, 0x0a, 0x97,
+       0x19, 0xbd, 0xd7, 0xef, 0xd7, 0xd1, 0x69, 0x5c,
+       0x33, 0x7a, 0x1b, 0x2a, 0xfd, 0xf4, 0xc6, 0x89,
+       0x09, 0xbd, 0x87, 0xc5, 0x8a, 0x1b, 0xaf, 0x1d,
+       0x4a, 0x21, 0xf5, 0xdd, 0x7b, 0x63, 0x25, 0xd8,
+       0x95, 0x44, 0xeb, 0x81, 0x9f, 0xb0, 0xdd, 0x19,
+       0xef, 0xa1, 0x6f, 0xbe, 0xcb, 0x14, 0xee, 0x18,
+       0x15, 0x39, 0x4f, 0x27, 0x00, 0x6c, 0xcf, 0xea,
+       0x93, 0x60, 0xb1, 0x53, 0x70, 0x7a, 0x43, 0x32,
+       0xdb, 0x53, 0xf0, 0x5e, 0xaa, 0x04, 0x3f, 0xbc,
+       0x20, 0xa5, 0xf3, 0xf7, 0xcf, 0xe9, 0xf3, 0x1c,
+       0xed, 0x2d, 0x0d, 0x8d, 0x72, 0x53, 0x4b, 0x63,
+       0x83, 0xd0, 0xd8, 0x12, 0x0c, 0xac, 0x14, 0x9a,
+       0x5a, 0x82, 0xad, 0x82, 0x27, 0x10, 0x9c, 0xd5,
+       0xda, 0xc2, 0xf6, 0x9b, 0xbc, 0xe7, 0x11, 0xe1,
+       0x87, 0xbb, 0x2c, 0x40, 0xef, 0x96, 0x40, 0xa1,
+       0x02, 0xc6, 0x78, 0xcd, 0x46, 0xbc, 0xea, 0xf5,
+       0x8e, 0x4e, 0x8f, 0x53, 0xe0, 0x07, 0x87, 0xd0,
+       0x5e, 0xf8, 0x65, 0xf8, 0x41, 0x17, 0x7d, 0x4d,
+       0xb7, 0x4b, 0x46, 0xcc, 0xcb, 0xb8, 0x3a, 0xe8,
+       0xe7, 0x56, 0x42, 0x28, 0x4a, 0x5b, 0x49, 0x39,
+       0x2b, 0x5f, 0x81, 0xb4, 0x49, 0xa0, 0xc4, 0x0b,
+       0x45, 0xa9, 0xc5, 0x51, 0x8c, 0x99, 0xeb, 0x89,
+       0xf7, 0x5b, 0x32, 0x7b, 0xf6, 0xf9, 0xf3, 0xcf,
+       0xb1, 0x76, 0x1e, 0xde, 0x7a, 0x8a, 0x77, 0xe3,
+       0xca, 0xe0, 0x87, 0x05, 0x42, 0x11, 0x5e, 0xd9,
+       0x97, 0x1c, 0xba, 0xb1, 0x75, 0x3f, 0xcc, 0x10,
+       0x8c, 0xb4, 0xa6, 0xfa, 0x09, 0xfb, 0xf2, 0x6c,
+       0x77, 0x16, 0x62, 0x92, 0x84, 0x18, 0x09, 0xf6,
+       0xb2, 0xf6, 0x77, 0x17, 0x60, 0xdc, 0x44, 0xf1,
+       0x9f, 0x38, 0x39, 0x1f, 0xad, 0xde, 0x86, 0x79,
+       0x5a, 0xbd, 0x7f, 0xb0, 0x91, 0x6c, 0xdb, 0x0f,
+       0x70, 0x7d, 0xf0, 0x2f, 0x7b, 0x65, 0x78, 0xa5,
+       0x9f, 0x6a, 0xfd, 0x2f, 0x5d, 0x18, 0xea, 0xdd,
+       0xf0, 0x74, 0x2b, 0xbc, 0x72, 0x09, 0xeb, 0x3e,
+       0x5d, 0xad, 0x7b, 0xd9, 0x90, 0xba, 0x5a, 0xd5,
+       0xba, 0x86, 0x90, 0x97, 0x4d, 0x24, 0x93, 0xf5,
+       0x49, 0xef, 0x59, 0x95, 0xbb, 0x17, 0xf3, 0x58,
+       0xf0, 0x67, 0x62, 0x27, 0xab, 0x99, 0x36, 0x75,
+       0x80, 0x21, 0x5f, 0x7f, 0x68, 0x00, 0xe6, 0xf0,
+       0x13, 0x81, 0x5e, 0x7c, 0x2b, 0x6d, 0x76, 0xb5,
+       0xdb, 0x3f, 0x3b, 0x91, 0xd9, 0xc0, 0x44, 0xf4,
+       0xdf, 0x51, 0x03, 0xae, 0x0a, 0x06, 0xaa, 0xf1,
+       0xd1, 0x3d, 0xa9, 0xb3, 0x07, 0xcb, 0xf8, 0xf0,
+       0x2d, 0xfe, 0x56, 0x7a, 0x40, 0x5a, 0x36, 0x75,
+       0x71, 0x20, 0x88, 0x7a, 0x3f, 0xb9, 0xad, 0x3e,
+       0xd0, 0xd8, 0xd8, 0x92, 0x15, 0x5c, 0x11, 0x64,
+       0x4f, 0xb4, 0xa9, 0x2d, 0xfa, 0xf5, 0xb8, 0x02,
+       0xa3, 0xbb, 0x15, 0xdb, 0x20, 0x83, 0x9d, 0x93,
+       0x53, 0x2e, 0xc1, 0xf3, 0x89, 0x9e, 0x15, 0x91,
+       0x48, 0x9a, 0xb3, 0xf2, 0x12, 0x5a, 0x29, 0x8d,
+       0xae, 0x0e, 0xe9, 0x02, 0xc3, 0xe9, 0xfe, 0x96,
+       0xde, 0xf2, 0xd3, 0xd1, 0xf7, 0x19, 0x95, 0x0c,
+       0x76, 0x52, 0xd4, 0xde, 0x9c, 0x89, 0x60, 0x3a,
+       0xd0, 0xd1, 0x0b, 0x17, 0x17, 0x24, 0x3c, 0x6c,
+       0xf3, 0x15, 0x5d, 0x8c, 0x5c, 0x9b, 0xf0, 0x2e,
+       0xc3, 0x5f, 0x04, 0xeb, 0x5c, 0x97, 0xdc, 0x27,
+       0xda, 0x18, 0xdd, 0x9b, 0xd1, 0x94, 0x37, 0x53,
+       0xc9, 0x0a, 0xc6, 0xa4, 0xb2, 0x6f, 0x55, 0xb9,
+       0x17, 0xe4, 0xbc, 0x41, 0xdc, 0xd8, 0xf7, 0xeb,
+       0x8c, 0x43, 0xbf, 0xbe, 0xcc, 0xe5, 0x6f, 0x36,
+       0x5b, 0xad, 0x36, 0x34, 0x70, 0x53, 0x13, 0x85,
+       0x45, 0x76, 0x5a, 0x45, 0xaa, 0xfd, 0xa1, 0x43,
+       0xad, 0x79, 0x6d, 0xaa, 0x0c, 0xdf, 0x5f, 0x45,
+       0xf2, 0x7f, 0xcd, 0x81, 0x21, 0xff, 0x24, 0x10,
+       0x62, 0x84, 0x41, 0x89, 0x17, 0x8a, 0xa0, 0xdb,
+       0x12, 0xa5, 0xc7, 0x15, 0xdc, 0x6b, 0x16, 0xa4,
+       0xf2, 0x32, 0x7a, 0xc0, 0x90, 0xf3, 0x26, 0x7a,
+       0x27, 0x7d, 0x29, 0x22, 0x4a, 0x2f, 0x4b, 0xf0,
+       0xbf, 0x4e, 0x21, 0x55, 0x32, 0xd1, 0xff, 0xaf,
+       0x6e, 0x0c, 0xd9, 0x6e, 0xa2, 0xa7, 0x2f, 0xa6,
+       0x4c, 0x8d, 0xd2, 0xe7, 0x23, 0xd5, 0x2b, 0x32,
+       0xec, 0xb8, 0xc4, 0xe8, 0xb7, 0x62, 0xe8, 0xec,
+       0x4d, 0xf4, 0x38, 0x12, 0x74, 0x96, 0x28, 0xbd,
+       0x09, 0xa9, 0x56, 0x21, 0xd5, 0x5e, 0x46, 0x8f,
+       0xfa, 0xbf, 0xa3, 0xeb, 0x26, 0xfa, 0x45, 0x22,
+       0x7d, 0x33, 0x47, 0xa5, 0x87, 0x0f, 0x5c, 0xfd,
+       0xba, 0x57, 0xad, 0x19, 0x68, 0x7d, 0x2d, 0xb2,
+       0xc0, 0x57, 0xfd, 0xe0, 0x0c, 0xa1, 0x2e, 0xbc,
+       0x9f, 0x01, 0x71, 0x1e, 0x27, 0x5e, 0x2d, 0x0c,
+       0xe7, 0xc6, 0x10, 0xce, 0x2b, 0x5d, 0x4e, 0xa4,
+       0xff, 0x2e, 0xc2, 0x02, 0xd6, 0x9b, 0xc5, 0xf4,
+       0xed, 0x81, 0x3d, 0x99, 0x2c, 0xec, 0xc1, 0xb1,
+       0xdf, 0xaf, 0xfb, 0x36, 0xa6, 0xa5, 0xd0, 0x48,
+       0xd8, 0x03, 0x18, 0x7b, 0x0a, 0x63, 0xf1, 0x2c,
+       0xb5, 0x82, 0x70, 0x3f, 0xbe, 0x8c, 0xb8, 0x20,
+       0xea, 0x75, 0x3f, 0xc7, 0x6d, 0xa0, 0x5a, 0x78,
+       0x88, 0xc7, 0x8f, 0x7b, 0x18, 0xa6, 0x4a, 0xf1,
+       0x21, 0xc5, 0x7c, 0xa4, 0x38, 0xc9, 0xe8, 0xf7,
+       0x61, 0x6c, 0x06, 0xc6, 0x8e, 0xb0, 0xd4, 0x1a,
+       0x86, 0xdb, 0x81, 0x38, 0x07, 0xe2, 0x76, 0x73,
+       0x1c, 0xe3, 0x51, 0xc5, 0x78, 0xbc, 0x24, 0x26,
+       0xba, 0xfa, 0xc1, 0x2d, 0x5a, 0xf0, 0xda, 0x28,
+       0x1a, 0xf1, 0x4a, 0x79, 0x9f, 0x55, 0x7b, 0xfc,
+       0x21, 0x7a, 0x97, 0xec, 0xb2, 0x4e, 0xbe, 0xce,
+       0x42, 0x67, 0x7a, 0x63, 0x94, 0x68, 0x68, 0x28,
+       0xae, 0xb2, 0xbd, 0xad, 0xbd, 0xbe, 0xbe, 0xb1,
+       0xad, 0xcd, 0x02, 0xec, 0xcb, 0x2b, 0x99, 0x42,
+       0xa0, 0xb1, 0xad, 0xb9, 0x55, 0x6a, 0x10, 0xe4,
+       0xf6, 0x16, 0xfe, 0xc9, 0x15, 0x59, 0xc2, 0xb9,
+       0xa0, 0x21, 0x9a, 0xfe, 0xc4, 0xe2, 0x06, 0x96,
+       0xde, 0xd2, 0x1a, 0x14, 0x24, 0xa4, 0x58, 0xde,
+       0x28, 0xb4, 0x06, 0x84, 0xd6, 0xe6, 0x86, 0x68,
+       0xca, 0xf2, 0xc6, 0x40, 0x1b, 0x66, 0xb4, 0x80,
+       0x4c, 0x93, 0x08, 0xd1, 0xc9, 0xad, 0x68, 0xe1,
+       0x84, 0x0c, 0xa4, 0x6b, 0x6e, 0x6c, 0x51, 0x82,
+       0x8b, 0x85, 0x69, 0x82, 0x63, 0xa2, 0x9a, 0x7e,
+       0x1f, 0xdc, 0x27, 0x50, 0x36, 0x34, 0x7e, 0x68,
+       0xf4, 0xd0, 0x1a, 0x72, 0x92, 0x69, 0x69, 0x30,
+       0x0d, 0xe6, 0x7b, 0x8a, 0x2b, 0x18, 0x47, 0x87,
+       0x23, 0xcb, 0x61, 0x81, 0xfa, 0xc5, 0x4d, 0xfe,
+       0x65, 0x8d, 0xcb, 0x04, 0x41, 0x48, 0x73, 0xb0,
+       0x3f, 0x61, 0x32, 0x85, 0xa1, 0x71, 0x05, 0x47,
+       0x63, 0xe6, 0xc9, 0x74, 0x99, 0x86, 0x97, 0xb6,
+       0x66, 0x09, 0x6b, 0x46, 0x38, 0x70, 0xf3, 0xbd,
+       0x3a, 0xd7, 0x67, 0xf5, 0x47, 0xae, 0x8f, 0xc1,
+       0x95, 0xd9, 0x67, 0x6b, 0x27, 0x55, 0x4c, 0xf8,
+       0x19, 0xc2, 0xf5, 0x13, 0x0e, 0xe3, 0x75, 0x75,
+       0x59, 0xff, 0x1d, 0x69, 0x99, 0x23, 0xfd, 0x09,
+       0x74, 0x12, 0xd4, 0x67, 0xab, 0x53, 0xf9, 0x37,
+       0x5c, 0xe8, 0xad, 0xc3, 0x01, 0xfe, 0x7d, 0x16,
+       0x1a, 0xbb, 0x9f, 0x3d, 0x3d, 0xa9, 0x34, 0xe7,
+       0x1e, 0x87, 0x2e, 0xbc, 0xa8, 0xab, 0xa6, 0xec,
+       0x32, 0x58, 0xe5, 0x6b, 0x79, 0x99, 0x91, 0xeb,
+       0x82, 0x89, 0xe7, 0x61, 0xa3, 0x19, 0xf9, 0x2a,
+       0x36, 0xc7, 0x40, 0x03, 0xfb, 0x06, 0x95, 0x04,
+       0xe3, 0x9e, 0xf6, 0x79, 0xc4, 0x0c, 0x76, 0xb2,
+       0x0a, 0xa5, 0x8c, 0x15, 0x06, 0x02, 0x0d, 0x42,
+       0x1a, 0xff, 0x06, 0x7b, 0x19, 0x7d, 0x55, 0x69,
+       0x2a, 0x7d, 0x91, 0x8a, 0x76, 0x7b, 0x8d, 0x5b,
+       0xe8, 0xf3, 0x14, 0x5d, 0x8e, 0xf4, 0xd9, 0x7e,
+       0xbd, 0x64, 0xc0, 0xbc, 0x03, 0x62, 0x23, 0x91,
+       0xaa, 0x77, 0x0a, 0xf4, 0x87, 0x3b, 0x22, 0xe0,
+       0x2d, 0xa6, 0x3b, 0x74, 0x23, 0x4e, 0xef, 0xe9,
+       0x88, 0x01, 0x16, 0x3a, 0xb0, 0xa7, 0xc3, 0x14,
+       0x0d, 0xe9, 0x78, 0x68, 0xfd, 0x9e, 0x0e, 0x3d,
+       0x0f, 0xad, 0xd8, 0xd3, 0x61, 0xe0, 0xa1, 0xc3,
+       0x45, 0xfd, 0x63, 0x36, 0x78, 0xd6, 0x9e, 0x70,
+       0xe7, 0x65, 0x0b, 0x30, 0xc5, 0x54, 0xf9, 0x13,
+       0xa1, 0x38, 0x73, 0x9c, 0x37, 0x96, 0x4e, 0x21,
+       0xce, 0x98, 0xf5, 0x0f, 0x9f, 0x53, 0xdb, 0x85,
+       0x91, 0x4c, 0x0b, 0xa8, 0x6e, 0x02, 0x6f, 0x45,
+       0x82, 0x5d, 0x49, 0x62, 0xe7, 0x42, 0x5f, 0x67,
+       0xe7, 0x42, 0xf7, 0x6e, 0x2c, 0x04, 0x61, 0xb4,
+       0x2b, 0x12, 0x11, 0x2f, 0x54, 0x9c, 0x69, 0xbd,
+       0x41, 0xef, 0x12, 0xe6, 0xb2, 0xd3, 0x40, 0x69,
+       0xbf, 0x6a, 0x65, 0xbb, 0x43, 0x27, 0xc2, 0xd8,
+       0x10, 0x93, 0x0d, 0xea, 0xfd, 0xc8, 0xb0, 0x88,
+       0xf5, 0x1c, 0x33, 0xc0, 0xe4, 0x40, 0xf1, 0x2e,
+       0x8c, 0x7f, 0x80, 0x35, 0x39, 0x4a, 0x7b, 0xb6,
+       0x46, 0x74, 0x8b, 0x30, 0x72, 0x7d, 0x73, 0xdb,
+       0x0a, 0xff, 0x13, 0x0d, 0x75, 0xfe, 0xa2, 0xfe,
+       0xf1, 0xd8, 0xfe, 0x11, 0x61, 0xfa, 0x22, 0xb2,
+       0xc3, 0xf4, 0x3b, 0xf6, 0xe4, 0xc3, 0xf6, 0x27,
+       0x38, 0x87, 0x38, 0x5b, 0xb0, 0xe0, 0xa0, 0x4b,
+       0xb6, 0x79, 0x41, 0xb1, 0x56, 0x83, 0x62, 0x9e,
+       0x0f, 0x8a, 0x71, 0x2e, 0xc8, 0xf2, 0xae, 0x42,
+       0x30, 0x2b, 0xe2, 0xaa, 0x27, 0x8f, 0x94, 0x2e,
+       0xd7, 0x21, 0xce, 0xba, 0x5c, 0xbf, 0x00, 0x14,
+       0x93, 0x37, 0x46, 0xae, 0x58, 0x0e, 0x0e, 0xd3,
+       0x15, 0xf2, 0xc6, 0xd0, 0xe3, 0xd1, 0xa1, 0x77,
+       0x3c, 0x32, 0xad, 0xda, 0xb0, 0x34, 0x0f, 0x39,
+       0x7f, 0xd3, 0x6b, 0x50, 0xe2, 0xfd, 0xa3, 0xc2,
+       0x31, 0x32, 0x7d, 0x01, 0xa4, 0xa1, 0x67, 0xa4,
+       0x98, 0x48, 0xdf, 0x27, 0x31, 0xc7, 0x80, 0x49,
+       0xb1, 0x98, 0xdf, 0x86, 0xd8, 0xe2, 0x18, 0x8c,
+       0x4f, 0xa6, 0x59, 0x6a, 0x2c, 0x7d, 0x91, 0xf9,
+       0x6f, 0xe8, 0xcd, 0xe9, 0x2f, 0x3e, 0x28, 0xbc,
+       0xc7, 0x51, 0x78, 0x16, 0xc2, 0xa5, 0x5d, 0x1d,
+       0x22, 0x7a, 0xd3, 0x91, 0x79, 0x8e, 0xc2, 0xad,
+       0x18, 0x93, 0x1d, 0x66, 0x13, 0xc4, 0xcb, 0x46,
+       0xaf, 0x4e, 0x4e, 0x2f, 0xea, 0x1f, 0xf7, 0x8c,
+       0xff, 0xc9, 0x70, 0x69, 0xe2, 0x5d, 0xe6, 0xb5,
+       0x74, 0x8e, 0xd6, 0x8a, 0x15, 0x87, 0x4d, 0x7b,
+       0x0a, 0xc1, 0x31, 0xff, 0xa0, 0x32, 0xb6, 0x4b,
+       0xaf, 0x24, 0x2f, 0x2a, 0xf3, 0x8e, 0x96, 0xcf,
+       0x91, 0xce, 0xa9, 0xed, 0x9d, 0xa4, 0xd7, 0x9b,
+       0x4c, 0x3a, 0x23, 0xa0, 0xd7, 0x66, 0x39, 0x3a,
+       0xb4, 0xcd, 0xc4, 0x53, 0x29, 0x44, 0x3f, 0x22,
+       0x56, 0xe9, 0xc6, 0xf6, 0x1f, 0x1f, 0xf3, 0x27,
+       0xf8, 0x80, 0x4b, 0xcf, 0x62, 0xbe, 0xad, 0x1c,
+       0x5e, 0x61, 0x72, 0x78, 0x49, 0x02, 0xab, 0xaf,
+       0x2a, 0xec, 0x36, 0x88, 0x16, 0xe4, 0xb6, 0x42,
+       0x82, 0xb8, 0x53, 0x92, 0x3b, 0xf8, 0xe4, 0xc1,
+       0x52, 0x4c, 0x9d, 0x2a, 0x5b, 0x8e, 0x76, 0x18,
+       0x42, 0x32, 0x7c, 0x61, 0xad, 0x6c, 0xf7, 0x1a,
+       0x95, 0xc4, 0x60, 0xec, 0xc1, 0x52, 0x69, 0x2c,
+       0xd2, 0x4d, 0xd5, 0xe4, 0x24, 0x26, 0xe5, 0x99,
+       0xae, 0x78, 0x0f, 0x62, 0xc8, 0x6b, 0x90, 0x8d,
+       0xbb, 0x40, 0x49, 0x74, 0xe8, 0xd5, 0x6f, 0x9d,
+       0xd0, 0x17, 0xbf, 0xfc, 0x41, 0xc7, 0x09, 0xb0,
+       0x1d, 0xc0, 0xfe, 0x2d, 0x7c, 0x07, 0xc2, 0x73,
+       0xbb, 0x3a, 0xc2, 0x68, 0xe5, 0x07, 0xde, 0xcc,
+       0xbf, 0xc7, 0x6c, 0x80, 0x91, 0x32, 0xbd, 0x25,
+       0xf0, 0x01, 0x51, 0x8b, 0x60, 0xd9, 0x85, 0xf5,
+       0xa4, 0x5e, 0xde, 0x59, 0xf5, 0xb6, 0xa8, 0x77,
+       0xc7, 0x38, 0x0a, 0xdf, 0x8a, 0x10, 0x7d, 0x88,
+       0xe8, 0x9f, 0x1d, 0x43, 0x67, 0x89, 0x60, 0x5b,
+       0x0a, 0xef, 0x79, 0xbd, 0x14, 0xdb, 0x69, 0x99,
+       0x77, 0x10, 0xaf, 0x23, 0xe6, 0x85, 0x4f, 0x02,
+       0x42, 0x2b, 0x41, 0x05, 0x06, 0x16, 0xfb, 0x0b,
+       0xc2, 0x2e, 0xd9, 0x8c, 0xd2, 0x8b, 0x60, 0x9e,
+       0x85, 0x73, 0x9c, 0xb2, 0x4d, 0x0d, 0x57, 0x52,
+       0x1e, 0xa4, 0x28, 0x35, 0xaf, 0x83, 0x91, 0x8a,
+       0x49, 0xb2, 0x62, 0x39, 0x5e, 0x7a, 0x43, 0x61,
+       0x68, 0x4d, 0xfd, 0xf5, 0x98, 0x6a, 0x95, 0x93,
+       0xfc, 0x6d, 0x08, 0x47, 0xc8, 0xf1, 0x88, 0x6b,
+       0xf2, 0x4b, 0x18, 0xa6, 0x9c, 0x56, 0x1b, 0xe9,
+       0x57, 0xc0, 0x5b, 0xaa, 0x58, 0xbd, 0x31, 0x0a,
+       0xfc, 0x89, 0xc6, 0xf2, 0x14, 0xf1, 0x20, 0xb6,
+       0xeb, 0x8e, 0x70, 0xc7, 0x80, 0xb3, 0xab, 0x63,
+       0x11, 0xd6, 0xf3, 0x4f, 0x17, 0xfc, 0x33, 0xc2,
+       0x73, 0x73, 0x40, 0x11, 0xe8, 0x04, 0xf2, 0x06,
+       0xba, 0xb7, 0x3f, 0xaa, 0x0e, 0xfe, 0xd4, 0x4d,
+       0xcf, 0x42, 0x1a, 0xe1, 0x4f, 0x87, 0x71, 0x04,
+       0x58, 0x44, 0x23, 0x5e, 0x27, 0x91, 0xee, 0x48,
+       0x70, 0xf7, 0x29, 0xc7, 0x3d, 0x12, 0x98, 0x3f,
+       0xe4, 0xe3, 0xc5, 0xd5, 0xc3, 0xbe, 0x2e, 0xf3,
+       0x30, 0x6a, 0xc4, 0x6b, 0x38, 0x62, 0x2c, 0xf5,
+       0xf1, 0x52, 0xa2, 0x1f, 0x90, 0x3a, 0xce, 0x80,
+       0xa3, 0x21, 0x25, 0xc7, 0x7b, 0xd7, 0x92, 0x01,
+       0xda, 0xb5, 0x2c, 0x82, 0xf9, 0x84, 0xbf, 0x37,
+       0x3c, 0x17, 0xcb, 0x5b, 0x4e, 0xf9, 0x2d, 0xa5,
+       0x62, 0xbc, 0xff, 0x2c, 0x8b, 0xcb, 0x2c, 0x8e,
+       0x2d, 0x33, 0x27, 0xe1, 0x2f, 0x48, 0xad, 0x73,
+       0xdc, 0x53, 0xf4, 0x19, 0xdc, 0x10, 0x27, 0x39,
+       0x74, 0x98, 0x82, 0x63, 0x27, 0x76, 0x00, 0x53,
+       0x58, 0xbb, 0x45, 0x1b, 0xe1, 0xe2, 0x68, 0xdf,
+       0xfc, 0xb3, 0x59, 0x4f, 0x60, 0xca, 0x39, 0x4e,
+       0x2b, 0xc4, 0x89, 0x70, 0xb7, 0x93, 0xa5, 0x9d,
+       0xc0, 0xb4, 0x40, 0x56, 0x33, 0xa6, 0x1d, 0x12,
+       0x30, 0xcd, 0x3c, 0x20, 0x9e, 0x63, 0xf8, 0x7d,
+       0xc4, 0x23, 0x0b, 0x3d, 0x91, 0xd8, 0xd7, 0x6c,
+       0x3a, 0x4f, 0x08, 0x73, 0x81, 0x78, 0x98, 0xa5,
+       0xec, 0x15, 0x4d, 0x0c, 0x1e, 0xa2, 0xf3, 0x2e,
+       0x94, 0x97, 0xc4, 0x37, 0x31, 0x7c, 0x4d, 0x84,
+       0xd8, 0x3d, 0x5a, 0x0f, 0x8a, 0xe6, 0xc1, 0x51,
+       0x1d, 0x77, 0x0a, 0x53, 0x76, 0x20, 0x97, 0x1d,
+       0x8e, 0xc2, 0x4f, 0xc3, 0x61, 0x17, 0xdd, 0xcd,
+       0x52, 0x8c, 0x22, 0xc4, 0xbd, 0xc6, 0x75, 0x22,
+       0x6e, 0x2f, 0xc9, 0xc9, 0x0f, 0xb6, 0x7b, 0x64,
+       0xe8, 0x5f, 0x6f, 0xc3, 0xb6, 0x25, 0xef, 0xc0,
+       0x1c, 0x07, 0x25, 0x33, 0x5e, 0x0f, 0xab, 0x7d,
+       0x87, 0xe9, 0x8e, 0x7b, 0x44, 0x48, 0x7e, 0xd6,
+       0xfa, 0xa8, 0x2e, 0xac, 0x5c, 0x11, 0xa1, 0x5f,
+       0xa4, 0x3e, 0x59, 0x5b, 0x80, 0x79, 0xe6, 0x39,
+       0xee, 0x58, 0xde, 0x46, 0x4f, 0x47, 0x65, 0xfd,
+       0xf2, 0x76, 0xdb, 0x5b, 0x18, 0xb2, 0xb0, 0x5d,
+       0xe5, 0x2d, 0x12, 0x98, 0x4e, 0x32, 0x1d, 0x34,
+       0xe3, 0xa8, 0x9e, 0x11, 0x2e, 0x42, 0xda, 0x49,
+       0x58, 0x1f, 0x2f, 0x7d, 0xe1, 0x36, 0xb6, 0x90,
+       0xf4, 0x9b, 0x46, 0xb9, 0xc3, 0x80, 0xb1, 0x3c,
+       0x87, 0xe1, 0x62, 0xad, 0x5a, 0x56, 0x03, 0x96,
+       0x9b, 0x46, 0x65, 0x2e, 0x87, 0x7c, 0x1c, 0xd9,
+       0x11, 0x08, 0x17, 0x29, 0x36, 0x8c, 0xcf, 0xa0,
+       0x1f, 0x7b, 0x1b, 0xb1, 0x4b, 0x34, 0x11, 0x4c,
+       0x7e, 0x1a, 0x53, 0x59, 0x8b, 0xcc, 0xac, 0x45,
+       0xe6, 0xd3, 0xbc, 0x45, 0xe6, 0x1e, 0xde, 0x73,
+       0x9f, 0xef, 0x63, 0x3d, 0xff, 0x8c, 0x98, 0xc4,
+       0x7b, 0xee, 0xf3, 0x57, 0x59, 0x7c, 0x03, 0x97,
+       0x9e, 0x79, 0x11, 0xd6, 0xaf, 0x06, 0xa9, 0xf7,
+       0x52, 0x29, 0xb1, 0x11, 0xaa, 0xdf, 0xe7, 0xeb,
+       0xcd, 0x4f, 0x61, 0x3b, 0x70, 0xc4, 0x98, 0x5f,
+       0xe2, 0xbc, 0x74, 0xf1, 0x68, 0xa3, 0x2c, 0x48,
+       0x15, 0xa2, 0xbd, 0xd9, 0x08, 0x71, 0xec, 0x9a,
+       0xd0, 0xbf, 0x32, 0xfb, 0x51, 0xf6, 0x31, 0x0a,
+       0x9d, 0x19, 0x5c, 0x45, 0xd6, 0xd2, 0x94, 0x21,
+       0x82, 0x89, 0xbe, 0xc0, 0x37, 0x81, 0x6c, 0xec,
+       0x5d, 0x47, 0x31, 0xb6, 0x10, 0x29, 0x0c, 0x0a,
+       0x5a, 0x4d, 0x53, 0x00, 0x63, 0x68, 0xe7, 0x4c,
+       0xd3, 0x11, 0xd6, 0x39, 0xee, 0xe8, 0xea, 0x70,
+       0x81, 0x62, 0xb7, 0x38, 0xe3, 0x20, 0xdc, 0xf1,
+       0x13, 0x1c, 0x39, 0x9f, 0x27, 0x8a, 0x16, 0x47,
+       0xa1, 0x2e, 0xc2, 0xea, 0x68, 0x46, 0x89, 0x3d,
+       0x05, 0x66, 0xfc, 0xc5, 0xc9, 0xe8, 0x19, 0x9b,
+       0x53, 0x58, 0x3d, 0x4c, 0xf4, 0xcd, 0xf5, 0xd8,
+       0x81, 0xa2, 0xfe, 0x7b, 0xfe, 0xf9, 0x6c, 0xb9,
+       0xed, 0x2e, 0x05, 0xfa, 0xce, 0x76, 0x21, 0x6f,
+       0xf3, 0x5d, 0x68, 0x87, 0xfa, 0x45, 0xec, 0x0f,
+       0x53, 0xfa, 0xe5, 0x32, 0xbf, 0x21, 0xec, 0x42,
+       0x9b, 0x44, 0xdf, 0x2d, 0xae, 0xaf, 0xc4, 0xc9,
+       0xbb, 0xa9, 0x6e, 0x86, 0x4e, 0xea, 0xc9, 0x19,
+       0x87, 0xb5, 0xb5, 0xd3, 0x0f, 0x39, 0xeb, 0x00,
+       0x64, 0xb3, 0x64, 0x65, 0x3c, 0x73, 0x24, 0x07,
+       0xc1, 0xa2, 0xfe, 0x94, 0x0b, 0x39, 0x86, 0x03,
+       0xb8, 0xf2, 0xd9, 0x39, 0x47, 0xb1, 0x78, 0xe7,
+       0x2c, 0x2a, 0x93, 0xaf, 0x8b, 0xd0, 0x17, 0xaa,
+       0x29, 0xa3, 0xaf, 0x9a, 0xa1, 0xc7, 0x6f, 0x66,
+       0x57, 0xbd, 0xed, 0x7d, 0x1c, 0x87, 0xb8, 0xae,
+       0x46, 0x7f, 0xb7, 0x96, 0x9d, 0x10, 0x38, 0x00,
+       0xb4, 0x5b, 0x17, 0xed, 0xd1, 0xbc, 0x8c, 0x48,
+       0xc4, 0x16, 0xae, 0x6c, 0xcf, 0xbb, 0xc7, 0xac,
+       0xa7, 0x2f, 0xa5, 0xf4, 0x15, 0x4b, 0x19, 0x6c,
+       0x54, 0xe8, 0xc5, 0x6e, 0xc7, 0x1d, 0x66, 0xf6,
+       0xf5, 0x94, 0x3e, 0x87, 0x74, 0x90, 0x70, 0x79,
+       0xf7, 0x88, 0xd6, 0xbc, 0x7b, 0x1c, 0x7a, 0xe2,
+       0x83, 0xd8, 0x64, 0xec, 0x7b, 0xd2, 0x82, 0x6f,
+       0x3a, 0xf4, 0x97, 0x3d, 0x52, 0x3c, 0xb3, 0x79,
+       0x7a, 0x29, 0x91, 0xdb, 0x76, 0xcc, 0x19, 0x23,
+       0x27, 0x87, 0x0b, 0x01, 0x5b, 0x60, 0x97, 0x59,
+       0xcc, 0x4a, 0x31, 0x59, 0xef, 0x17, 0x10, 0x53,
+       0xc3, 0x9e, 0xc2, 0xc3, 0x1f, 0x3f, 0xa0, 0x77,
+       0x89, 0x11, 0x1e, 0x23, 0xdd, 0xc1, 0xf4, 0x58,
+       0x7e, 0x7e, 0x21, 0xff, 0xb6, 0x95, 0x08, 0xc6,
+       0x0f, 0x58, 0x3f, 0xa4, 0x48, 0x10, 0x63, 0x9d,
+       0x9c, 0x21, 0x81, 0x71, 0x0f, 0x86, 0x12, 0x26,
+       0x66, 0xb2, 0xf0, 0x7a, 0xfa, 0x92, 0x14, 0x9d,
+       0xea, 0x6e, 0x7c, 0x15, 0x7f, 0x6b, 0x71, 0x36,
+       0xb1, 0xe5, 0xdd, 0x71, 0xb0, 0xe3, 0xbf, 0x47,
+       0x76, 0x31, 0x9b, 0xf8, 0xc7, 0x55, 0x58, 0x3f,
+       0x7d, 0xce, 0x3d, 0x17, 0x17, 0xa0, 0x84, 0xaf,
+       0x07, 0x6d, 0xe6, 0x35, 0x58, 0xa2, 0x3e, 0x68,
+       0x47, 0x48, 0x3d, 0x6b, 0x5b, 0xeb, 0x46, 0xbc,
+       0xbc, 0xd6, 0x4d, 0xa7, 0x48, 0x6b, 0xa3, 0x09,
+       0xfd, 0x8d, 0x0e, 0x07, 0xca, 0x48, 0x36, 0xd2,
+       0x7c, 0x82, 0xd2, 0xbd, 0x9f, 0xbe, 0x1e, 0x3d,
+       0xe6, 0x53, 0x30, 0xf2, 0xf1, 0x68, 0x38, 0x8b,
+       0xd4, 0xa5, 0x0e, 0xdd, 0xef, 0xd9, 0x7c, 0x92,
+       0xaf, 0xbb, 0x50, 0x7e, 0xa8, 0x03, 0x0a, 0x42,
+       0x45, 0x39, 0x80, 0xbc, 0x92, 0xd5, 0xb1, 0xa8,
+       0x5b, 0x62, 0xa2, 0x99, 0xae, 0x98, 0xbe, 0x72,
+       0x9a, 0x8c, 0x6b, 0xa6, 0x1e, 0xef, 0x1d, 0x32,
+       0x5c, 0xbf, 0x3c, 0x43, 0x37, 0x38, 0x56, 0xaf,
+       0x7f, 0x48, 0x63, 0x35, 0x69, 0x80, 0xfa, 0x37,
+       0x06, 0xe7, 0x61, 0x43, 0x27, 0x8d, 0xc8, 0x78,
+       0x1c, 0x91, 0xd7, 0x0f, 0x3a, 0xee, 0x20, 0x59,
+       0x20, 0xee, 0x34, 0xb7, 0x4e, 0x97, 0x3d, 0x6a,
+       0x1c, 0xf5, 0x32, 0x66, 0x77, 0xf0, 0x09, 0x94,
+       0x48, 0x9c, 0xa2, 0x0f, 0x36, 0xdb, 0x0e, 0x20,
+       0xae, 0x2a, 0xed, 0x8e, 0x83, 0xfb, 0xe2, 0x0b,
+       0x58, 0xce, 0xf5, 0x69, 0x77, 0xf0, 0xbe, 0xbb,
+       0xbc, 0x5e, 0xc2, 0x35, 0xa3, 0xe1, 0x54, 0x66,
+       0x06, 0x8d, 0x99, 0x1b, 0xb4, 0x46, 0xfb, 0x70,
+       0xe2, 0x54, 0x74, 0xc2, 0xef, 0xa1, 0xef, 0x14,
+       0xf0, 0xef, 0x6f, 0xd1, 0xe9, 0x85, 0x2a, 0xdf,
+       0x20, 0xf6, 0x1a, 0x18, 0x5e, 0x9d, 0x8a, 0x63,
+       0xd7, 0xb0, 0x98, 0xe9, 0xc1, 0x08, 0x05, 0xae,
+       0x17, 0x8a, 0x16, 0x1e, 0x46, 0xce, 0xe8, 0x0f,
+       0xc7, 0x54, 0xa9, 0x5a, 0x01, 0x5f, 0xec, 0xc5,
+       0x59, 0xde, 0x85, 0x70, 0x0f, 0x8d, 0x44, 0xe3,
+       0x71, 0x9a, 0x61, 0xfd, 0x54, 0x2b, 0x50, 0xf4,
+       0xfe, 0x66, 0x5b, 0x18, 0x57, 0x5f, 0xaa, 0x55,
+       0xd2, 0xe9, 0x64, 0x13, 0x59, 0x9e, 0xa4, 0x44,
+       0x81, 0xae, 0xf1, 0x34, 0xba, 0x8c, 0xdb, 0x25,
+       0xbd, 0x78, 0x94, 0x8f, 0xe9, 0xcf, 0x4e, 0x52,
+       0xaa, 0x71, 0x1f, 0x62, 0xf6, 0xf2, 0x51, 0xff,
+       0xd9, 0x21, 0x86, 0x79, 0xde, 0xfb, 0xe8, 0xfc,
+       0x77, 0xd0, 0xff, 0xe9, 0xa3, 0xf9, 0x2d, 0x13,
+       0xfb, 0xf2, 0xb3, 0xd7, 0x1c, 0xf7, 0x90, 0xce,
+       0x22, 0xef, 0x43, 0x98, 0xde, 0x65, 0x7d, 0x34,
+       0x0d, 0x88, 0xc2, 0xfa, 0xe8, 0x56, 0x4a, 0xdd,
+       0xc0, 0x70, 0x77, 0x40, 0x9e, 0x82, 0xa3, 0xfd,
+       0xb3, 0xb5, 0x18, 0x72, 0xc8, 0xd7, 0x1d, 0xf7,
+       0x04, 0xec, 0x07, 0x9c, 0x72, 0x72, 0x20, 0x36,
+       0xd8, 0x76, 0xc0, 0xa9, 0x98, 0x83, 0x0d, 0xd5,
+       0x3a, 0xa4, 0x6d, 0x20, 0xb9, 0xe9, 0xdf, 0x94,
+       0xeb, 0x45, 0xfb, 0xce, 0x0e, 0xb0, 0x2b, 0xf0,
+       0x99, 0x2f, 0x30, 0x81, 0xc6, 0x82, 0xa2, 0x0f,
+       0x34, 0xd8, 0xf6, 0x4b, 0x70, 0x07, 0x9d, 0x3d,
+       0xf2, 0x62, 0xe6, 0x84, 0x4b, 0xb8, 0xf2, 0xd1,
+       0xd7, 0x52, 0xbf, 0x7c, 0xd1, 0xd7, 0xd5, 0x21,
+       0xd8, 0x30, 0x2f, 0xca, 0xd3, 0xb6, 0x0f, 0x02,
+       0xb4, 0x37, 0x44, 0xd6, 0x2f, 0xa4, 0x33, 0x3e,
+       0xba, 0xf9, 0x3c, 0x95, 0x88, 0xfe, 0x96, 0x31,
+       0x99, 0x68, 0x3f, 0xb2, 0x77, 0x75, 0xac, 0x41,
+       0xda, 0x6b, 0x03, 0x79, 0x77, 0x48, 0xdd, 0xc8,
+       0xa9, 0x26, 0x73, 0x82, 0x43, 0xff, 0xbb, 0x5a,
+       0xf4, 0x0b, 0x70, 0x06, 0xbe, 0x76, 0x01, 0x69,
+       0x5f, 0xa2, 0x27, 0x89, 0x99, 0xd2, 0x6f, 0x6b,
+       0xa9, 0x54, 0x11, 0x12, 0x37, 0xa1, 0x9c, 0xdd,
+       0xb8, 0x3e, 0x82, 0x6b, 0x87, 0xa5, 0x14, 0x1a,
+       0x61, 0x6a, 0x6c, 0xaf, 0x94, 0xbc, 0x51, 0x7f,
+       0x00, 0xc7, 0x04, 0xe6, 0x7b, 0x4d, 0x1d, 0xa1,
+       0xd8, 0x33, 0xd7, 0xb6, 0x0f, 0xf6, 0xcc, 0xb5,
+       0xe7, 0x1d, 0x85, 0x4f, 0xf5, 0x85, 0xdd, 0x18,
+       0x7a, 0x46, 0x9b, 0x3f, 0xb0, 0x2f, 0x99, 0xfd,
+       0xcb, 0xd1, 0x23, 0x8d, 0x85, 0xce, 0x50, 0xd4,
+       0x3d, 0x43, 0x63, 0x93, 0xc6, 0x81, 0x6e, 0xed,
+       0xc5, 0x05, 0x18, 0xef, 0xe0, 0x7c, 0x31, 0xd7,
+       0x3c, 0x3a, 0x2d, 0xc8, 0x70, 0xfa, 0xf7, 0x98,
+       0x66, 0x38, 0x8e, 0x23, 0x23, 0x9e, 0x8f, 0x0e,
+       0xf3, 0x7e, 0x88, 0xc1, 0x1f, 0xe6, 0x35, 0xd4,
+       0xb2, 0xb4, 0xe9, 0x6a, 0x9a, 0x35, 0x9a, 0x1e,
+       0x4f, 0x34, 0x98, 0x5e, 0xc0, 0xd2, 0xc7, 0xb2,
+       0x1c, 0x3a, 0xac, 0xab, 0x99, 0x4e, 0x47, 0x42,
+       0x0c, 0x9d, 0x2a, 0x48, 0x67, 0xf5, 0x5c, 0x62,
+       0x96, 0xcb, 0x82, 0x96, 0x0b, 0xcb, 0x45, 0x89,
+       0x5e, 0x43, 0xbc, 0x51, 0xb5, 0xcf, 0xf4, 0xe4,
+       0x90, 0xce, 0xcd, 0xe9, 0x41, 0xb8, 0x0f, 0x21,
+       0xfa, 0xaf, 0xec, 0x6b, 0x88, 0xc7, 0x24, 0x92,
+       0x6d, 0x72, 0x26, 0x5a, 0x80, 0x2f, 0x0e, 0x91,
+       0xf5, 0xfc, 0x3c, 0x1f, 0xb1, 0x38, 0xa7, 0xea,
+       0x8f, 0xd0, 0x77, 0x13, 0x91, 0x9f, 0x59, 0x31,
+       0x8b, 0x09, 0xfc, 0xc4, 0x28, 0xff, 0x13, 0xda,
+       0x7c, 0x29, 0x5a, 0xfc, 0xcd, 0x9a, 0x14, 0x48,
+       0x2b, 0x6d, 0x61, 0x31, 0xcb, 0xa1, 0xbb, 0xe0,
+       0xd9, 0xd0, 0x81, 0xab, 0x64, 0x33, 0x85, 0x44,
+       0x3d, 0x8d, 0x70, 0xa0, 0xe7, 0x51, 0x61, 0x05,
+       0xfe, 0x50, 0x7b, 0xd9, 0xc3, 0xd6, 0x27, 0x9c,
+       0xfa, 0x4f, 0x40, 0xf6, 0x5a, 0x88, 0xae, 0x2d,
+       0x2c, 0x51, 0xaf, 0xe3, 0xce, 0xca, 0xf6, 0xba,
+       0x27, 0x9a, 0x27, 0xf1, 0x19, 0x02, 0xc7, 0x29,
+       0xfc, 0xbe, 0x16, 0xed, 0x18, 0xce, 0xb1, 0x63,
+       0xb6, 0xaa, 0xf3, 0x9e, 0x24, 0x9a, 0xb5, 0x19,
+       0x50, 0xa3, 0x18, 0x62, 0xc9, 0x6e, 0x43, 0x31,
+       0xcc, 0xd2, 0x65, 0x4a, 0x99, 0xb2, 0xff, 0x8a,
+       0x47, 0xec, 0xe1, 0x36, 0xfd, 0x4e, 0x7a, 0x1b,
+       0x82, 0x85, 0x92, 0xfa, 0x79, 0x2e, 0x0c, 0x5d,
+       0xb3, 0xfd, 0xbd, 0x79, 0x33, 0xca, 0x17, 0x57,
+       0x02, 0x53, 0xe2, 0x52, 0x5b, 0xc1, 0x48, 0x16,
+       0x3e, 0xf5, 0xf1, 0x9a, 0xbf, 0x1b, 0x1a, 0x57,
+       0xad, 0x3d, 0xe2, 0x6b, 0x11, 0x6f, 0xbb, 0xab,
+       0x1a, 0x96, 0x22, 0x5e, 0x64, 0xab, 0x07, 0x2c,
+       0xb3, 0x00, 0xdb, 0x2d, 0xc8, 0xd6, 0xe0, 0xa8,
+       0x73, 0xe5, 0xbf, 0xa9, 0xa2, 0x33, 0x82, 0xf2,
+       0xc1, 0x1d, 0xe3, 0x76, 0xfb, 0x1b, 0x24, 0xbd,
+       0x5f, 0x5a, 0x61, 0xf6, 0x16, 0x2b, 0x15, 0x31,
+       0x06, 0xd9, 0xe4, 0x73, 0x57, 0x17, 0x8b, 0x57,
+       0xbd, 0x6f, 0xab, 0xef, 0x97, 0x85, 0x6d, 0x6b,
+       0x4d, 0x36, 0x70, 0x60, 0xe9, 0x06, 0x37, 0x4b,
+       0x53, 0xcc, 0x31, 0x06, 0xc5, 0x58, 0x75, 0x08,
+       0x69, 0x4c, 0x6c, 0x76, 0x9f, 0xac, 0xd2, 0x4c,
+       0x21, 0x1a, 0xe4, 0x62, 0xaa, 0x2e, 0xf6, 0xb9,
+       0xc5, 0x2e, 0xad, 0x54, 0x05, 0x3e, 0xbd, 0x42,
+       0x7b, 0x72, 0x10, 0x5e, 0xe8, 0xf0, 0x1f, 0x7d,
+       0x6a, 0x1f, 0x8e, 0xb5, 0x8e, 0x48, 0x4f, 0xfc,
+       0x69, 0x94, 0x00, 0xab, 0xd1, 0x58, 0xf2, 0x75,
+       0x31, 0xf5, 0x30, 0x42, 0xab, 0x0c, 0x9f, 0x86,
+       0x83, 0xb1, 0xe7, 0x46, 0xfc, 0x86, 0xde, 0x93,
+       0xe8, 0x4f, 0x02, 0xd1, 0x4c, 0x58, 0x4c, 0x7d,
+       0x05, 0xe1, 0x08, 0x25, 0xde, 0xbb, 0x6e, 0x29,
+       0x7c, 0xfa, 0x22, 0xfb, 0x66, 0xee, 0xa1, 0xca,
+       0x76, 0x37, 0x04, 0x63, 0xbd, 0xee, 0xa5, 0xd7,
+       0xb1, 0xde, 0xc6, 0x6a, 0xb7, 0x78, 0xcd, 0x1b,
+       0x8e, 0xbe, 0x15, 0xc7, 0x7c, 0x56, 0x1c, 0xaf,
+       0x0f, 0xfe, 0xad, 0xdd, 0x6d, 0xaa, 0x76, 0x2f,
+       0xd5, 0x6a, 0x7d, 0x0d, 0x6b, 0x9d, 0xc0, 0x6a,
+       0x3d, 0x48, 0x93, 0xff, 0xb7, 0x76, 0xe4, 0xd2,
+       0x85, 0x1c, 0x76, 0x16, 0xf5, 0x27, 0x6e, 0x08,
+       0x77, 0x8c, 0x82, 0x2b, 0x9e, 0x22, 0xb4, 0xfd,
+       0x9a, 0x44, 0x69, 0x36, 0x48, 0xdc, 0x4c, 0x77,
+       0xa1, 0xbb, 0x9d, 0x1c, 0xaf, 0xe2, 0x5e, 0x42,
+       0xdc, 0xb8, 0x6e, 0xa7, 0x86, 0x45, 0xea, 0xf8,
+       0x61, 0x33, 0xef, 0xaf, 0x55, 0x29, 0xcc, 0xc0,
+       0x96, 0x3e, 0x54, 0xcf, 0xe6, 0x15, 0xea, 0x51,
+       0xf2, 0xc4, 0xcf, 0x7b, 0x3c, 0xab, 0xc0, 0xe2,
+       0x78, 0x18, 0x4c, 0xef, 0x63, 0x6f, 0x81, 0x0d,
+       0x04, 0xc8, 0x83, 0x79, 0xb0, 0x02, 0xb6, 0xc0,
+       0x51, 0x7d, 0x1f, 0xb5, 0xd0, 0x1f, 0x1b, 0x76,
+       0x0d, 0xd1, 0x13, 0xe9, 0xa6, 0x78, 0xa6, 0xfa,
+       0xbd, 0xc5, 0x21, 0x78, 0xb2, 0xee, 0x68, 0x95,
+       0xd1, 0x5b, 0x31, 0xd6, 0x7c, 0x39, 0x05, 0xfe,
+       0xee, 0x47, 0x2a, 0xf4, 0x2c, 0x8c, 0x59, 0xaa,
+       0x24, 0x32, 0xa2, 0x14, 0x48, 0xad, 0xf1, 0x31,
+       0xa0, 0x37, 0x61, 0x24, 0x8f, 0x23, 0xc3, 0x71,
+       0x07, 0xbd, 0x93, 0xa5, 0xe9, 0xf2, 0xcd, 0xe5,
+       0x19, 0x8e, 0x39, 0xee, 0xf1, 0x84, 0xdf, 0x7f,
+       0x03, 0xc7, 0xcb, 0x3a, 0x1c, 0xfb, 0xa7, 0xcc,
+       0x77, 0xd0, 0xf7, 0xaa, 0x61, 0x0b, 0xa6, 0xec,
+       0x8a, 0xe6, 0x36, 0xd3, 0x17, 0x56, 0x38, 0xcd,
+       0x6d, 0xf9, 0x64, 0xfa, 0x1b, 0x30, 0x5f, 0x2c,
+       0xce, 0x22, 0x58, 0xbe, 0xdf, 0x1f, 0xbe, 0xa3,
+       0xc7, 0xcc, 0xd3, 0x68, 0x07, 0xa9, 0xa3, 0x10,
+       0x7a, 0xc3, 0x77, 0x9c, 0x67, 0x6f, 0x7e, 0x7d,
+       0xf6, 0x6c, 0x6a, 0x36, 0xfb, 0x92, 0x69, 0x96,
+       0xbf, 0x19, 0x73, 0x60, 0xcf, 0xfb, 0x9f, 0xf0,
+       0xec, 0xc7, 0x3c, 0xa6, 0xf0, 0x1d, 0x8a, 0xe5,
+       0x1c, 0x8d, 0x98, 0x49, 0x38, 0x9a, 0xed, 0x1f,
+       0x7d, 0xff, 0x17, 0x5a, 0x69, 0x13, 0x69, 0x8f,
+       0x69, 0xcd, 0x2c, 0xb2, 0x64, 0xd9, 0x39, 0x79,
+       0x05, 0x7e, 0x33, 0xcd, 0x36, 0x86, 0x44, 0xff,
+       0x4c, 0x9c, 0x61, 0x0a, 0xa1, 0xb8, 0x01, 0x0c,
+       0x66, 0x84, 0x46, 0x05, 0x0c, 0xe0, 0x77, 0x84,
+       0xe7, 0x2a, 0xa0, 0xef, 0x9b, 0xa1, 0xcf, 0xbb,
+       0x47, 0x95, 0x8b, 0x9b, 0xe9, 0xd4, 0x23, 0xe8,
+       0x07, 0xa3, 0xbf, 0x0a, 0x0f, 0xcb, 0xb5, 0x48,
+       0xe3, 0xee, 0xf1, 0xa0, 0x7d, 0x8d, 0xa5, 0x33,
+       0x6f, 0x75, 0x63, 0xad, 0x19, 0xf0, 0x88, 0xfa,
+       0x3e, 0x26, 0xb5, 0x6b, 0x95, 0x98, 0x89, 0xab,
+       0xc8, 0x0c, 0xfc, 0x59, 0x85, 0x91, 0xdd, 0xff,
+       0x63, 0x2e, 0xfa, 0x9f, 0xa3, 0x6c, 0x62, 0x22,
+       0xc9, 0xa8, 0xfb, 0xbf, 0x2d, 0xa0, 0x98, 0x9e,
+       0x59, 0x9c, 0x01, 0x78, 0x42, 0xcd, 0xe1, 0x27,
+       0xbf, 0x4f, 0x9c, 0xca, 0xf9, 0xa2, 0x15, 0x3c,
+       0x4a, 0x92, 0x21, 0xfe, 0xb2, 0xa0, 0xf2, 0xa6,
+       0x77, 0x3e, 0x33, 0x86, 0x94, 0x21, 0xa9, 0x27,
+       0x3d, 0x9b, 0xbc, 0x24, 0xe9, 0xcd, 0x48, 0xab,
+       0x67, 0x69, 0x8f, 0x62, 0xc8, 0x24, 0xd7, 0xdc,
+       0x2e, 0x97, 0xbf, 0xc1, 0xeb, 0x5e, 0xc2, 0xa4,
+       0xeb, 0x28, 0xf4, 0x43, 0xd8, 0xad, 0xfa, 0x82,
+       0x61, 0x55, 0x92, 0x34, 0xa3, 0xe8, 0xfd, 0x4f,
+       0x50, 0xaa, 0x09, 0x53, 0x15, 0xcb, 0xef, 0x6b,
+       0x55, 0x49, 0x1a, 0x45, 0x2b, 0x49, 0xcd, 0x51,
+       0x78, 0x03, 0xf1, 0xf2, 0x24, 0x26, 0x11, 0x0b,
+       0x95, 0x28, 0xb3, 0x12, 0xd1, 0x77, 0x75, 0x2b,
+       0x74, 0x02, 0xb5, 0x8e, 0x97, 0xc3, 0x7c, 0xd4,
+       0x89, 0x79, 0xe3, 0x70, 0x74, 0xc6, 0x8a, 0x7d,
+       0x28, 0x85, 0x64, 0x5a, 0x53, 0x0b, 0xe8, 0x7d,
+       0xc4, 0x5b, 0x70, 0x34, 0x10, 0x8c, 0xb6, 0x1f,
+       0x67, 0x79, 0xd2, 0x01, 0xe7, 0x4d, 0x23, 0x21,
+       0x07, 0xdc, 0xd0, 0x00, 0x03, 0xba, 0x0e, 0xfa,
+       0xc7, 0x7a, 0x01, 0xbd, 0x17, 0xd5, 0xaf, 0x72,
+       0x4a, 0x30, 0xf2, 0x80, 0xaa, 0xc5, 0x2a, 0x0f,
+       0xa2, 0x20, 0xfe, 0x23, 0x5f, 0x19, 0xfc, 0x0e,
+       0xa9, 0xff, 0x46, 0xf7, 0xa3, 0x24, 0x6f, 0xc4,
+       0x6e, 0x1a, 0x2a, 0x65, 0x4e, 0xc1, 0x35, 0xf4,
+       0x8b, 0x3e, 0xae, 0x9d, 0xa4, 0x99, 0xdd, 0xff,
+       0x8d, 0xde, 0x47, 0xfa, 0x6c, 0x1d, 0xd2, 0x37,
+       0xdc, 0x44, 0xff, 0x5f, 0xa2, 0x99, 0xf0, 0x12,
+       0xc9, 0x58, 0x5b, 0xaf, 0x79, 0xd9, 0x7d, 0x1e,
+       0x39, 0x09, 0xf5, 0x2d, 0x52, 0x6f, 0xd5, 0x56,
+       0x50, 0xb4, 0x2b, 0x44, 0x04, 0xeb, 0x41, 0xbe,
+       0xb7, 0x12, 0xd3, 0x71, 0x6e, 0xb4, 0xee, 0xe6,
+       0x7b, 0x32, 0x31, 0x96, 0xe0, 0x71, 0x92, 0xff,
+       0x64, 0x7d, 0xc9, 0xca, 0xef, 0x82, 0x3d, 0xa5,
+       0x38, 0xac, 0x0f, 0x71, 0xdf, 0x55, 0x8e, 0xa7,
+       0x34, 0x5c, 0x07, 0x2d, 0x24, 0x5f, 0xcc, 0x5a,
+       0x8b, 0xf8, 0x18, 0x46, 0x11, 0x6f, 0xa5, 0x7d,
+       0x29, 0x8c, 0x97, 0x74, 0x5a, 0x64, 0xf7, 0x51,
+       0xd8, 0x29, 0xab, 0xd8, 0x16, 0xea, 0x99, 0x8f,
+       0x3d, 0x13, 0x3e, 0x45, 0xbb, 0x84, 0x75, 0x4d,
+       0x7d, 0x1c, 0xa5, 0xc6, 0x4b, 0x5a, 0xab, 0x14,
+       0xa8, 0xa1, 0x6f, 0x29, 0x59, 0x53, 0xcc, 0x74,
+       0xa7, 0xf4, 0xb3, 0x75, 0xd1, 0xd9, 0x32, 0x9f,
+       0xd6, 0xe8, 0xac, 0xfe, 0x4f, 0x2b, 0x46, 0x8c,
+       0xa3, 0xff, 0x39, 0xe2, 0x3c, 0xed, 0xdb, 0xfa,
+       0xec, 0x69, 0x76, 0x46, 0x3b, 0xa8, 0xf7, 0xc1,
+       0xbe, 0x85, 0x2b, 0x16, 0x58, 0x62, 0x2a, 0x26,
+       0x79, 0x4d, 0x0e, 0xd3, 0x9d, 0xf4, 0x88, 0x3a,
+       0xf7, 0x7e, 0x8b, 0xd6, 0x66, 0xd6, 0x3a, 0x76,
+       0x27, 0xeb, 0x24, 0x3f, 0x35, 0x71, 0x48, 0x1e,
+       0x27, 0xe6, 0x71, 0x6a, 0x79, 0x22, 0xc3, 0xf3,
+       0x64, 0xb1, 0x3c, 0x2f, 0x51, 0x1e, 0xfa, 0xa2,
+       0x0f, 0xc4, 0xd3, 0xcb, 0x89, 0x50, 0x60, 0xd8,
+       0x68, 0x58, 0x6b, 0x38, 0x64, 0xd8, 0x6d, 0xb8,
+       0x60, 0xe8, 0x33, 0x9a, 0x8d, 0x69, 0xc6, 0xa9,
+       0xc6, 0x62, 0x43, 0x8b, 0x71, 0x4f, 0x4c, 0x52,
+       0x8c, 0x60, 0x84, 0x11, 0x36, 0xcb, 0x33, 0x31,
+       0xde, 0x18, 0x5f, 0xcc, 0xc2, 0x98, 0x96, 0x98,
+       0x15, 0x31, 0x1d, 0xb1, 0x81, 0xd8, 0x2e, 0x8b,
+       0x6c, 0xf1, 0x5b, 0x5e, 0xb5, 0x1c, 0xb2, 0x9c,
+       0xb3, 0x5c, 0xb2, 0x5c, 0x1d, 0x61, 0x1d, 0x61,
+       0x32, 0x59, 0x21, 0x27, 0x26, 0xcd, 0xb4, 0xc9,
+       0xd4, 0x6c, 0x0a, 0x99, 0x06, 0x0c, 0xaf, 0x19,
+       0x5e, 0x8c, 0x3d, 0x1c, 0xdb, 0x63, 0x4e, 0x34,
+       0x07, 0xcd, 0x21, 0xf3, 0x66, 0x73, 0xb7, 0x79,
+       0xab, 0xa5, 0xdf, 0x92, 0x6c, 0x89, 0x8f, 0xbb,
+       0x1e, 0xd7, 0x13, 0x6b, 0x34, 0x5c, 0x31, 0x9f,
+       0x32, 0x7f, 0x60, 0xa8, 0x88, 0x31, 0x99, 0xfb,
+       0xf5, 0x87, 0x62, 0x76, 0xc4, 0x6c, 0x8c, 0x4b,
+       0x8e, 0x2b, 0x88, 0x7b, 0x3a, 0xae, 0x2b, 0xe6,
+       0x52, 0xcc, 0x8d, 0xd8, 0x1c, 0xe3, 0x75, 0x43,
+       0xa1, 0xf9, 0xb2, 0xb9, 0xc7, 0xd0, 0x6d, 0x38,
+       0x19, 0x97, 0x15, 0x97, 0x1a, 0x07, 0x26, 0x73,
+       0x6c, 0x85, 0xb1, 0xca, 0xb8, 0x10, 0xce, 0xeb,
+       0x53, 0xf4, 0x76, 0xdd, 0x95, 0x48, 0xc4, 0x3b,
+       0x60, 0xd4, 0x35, 0xb1, 0x6f, 0x72, 0x5f, 0xc6,
+       0x76, 0x56, 0xfa, 0x8d, 0xba, 0x40, 0x63, 0x5b,
+       0xe3, 0x35, 0xb6, 0x23, 0xba, 0xf2, 0x1b, 0x46,
+       0x5d, 0x4b, 0x6b, 0xaf, 0xba, 0x3f, 0xba, 0xb2,
+       0x0d, 0xd3, 0x82, 0x1f, 0x6b, 0xb1, 0x76, 0x8a,
+       0xfd, 0x41, 0x8b, 0x3d, 0x41, 0xb1, 0xab, 0x6a,
+       0xcc, 0xdb, 0x6f, 0xd4, 0xd5, 0x29, 0x2d, 0xe7,
+       0x59, 0x2c, 0x7c, 0x15, 0x8c, 0x8b, 0x2e, 0x68,
+       0xbb, 0xac, 0x31, 0x66, 0x78, 0x54, 0x5e, 0xd6,
+       0xba, 0xbc, 0x31, 0xeb, 0x32, 0x8f, 0x3d, 0xc6,
+       0x62, 0xcb, 0xb2, 0x2e, 0xb3, 0xd8, 0xe3, 0x6a,
+       0xac, 0x2f, 0x12, 0xc1, 0x58, 0x09, 0x8b, 0xd5,
+       0x5f, 0x45, 0x9e, 0x57, 0x43, 0xc6, 0x62, 0x59,
+       0xad, 0x4c, 0x24, 0xf2, 0x99, 0xcd, 0xa8, 0xf3,
+       0xcb, 0xcd, 0xed, 0x6d, 0x8b, 0x25, 0x6c, 0xc3,
+       0x67, 0xf6, 0x68, 0x6c, 0x5b, 0x24, 0xd2, 0x0b,
+       0x46, 0x0f, 0x8f, 0x7d, 0x04, 0x14, 0x33, 0xcc,
+       0xe5, 0xb1, 0x3f, 0x60, 0x79, 0x18, 0x9b, 0xc7,
+       0x63, 0xc8, 0xb3, 0xef, 0x33, 0xf4, 0x3c, 0x79,
+       0xec, 0x0a, 0xc5, 0xcc, 0x6a, 0xac, 0x07, 0x28,
+       0xe6, 0xc1, 0x58, 0xb0, 0xb1, 0x2d, 0xf8, 0x47,
+       0x16, 0x5b, 0xac, 0xc6, 0xae, 0x02, 0xe7, 0x59,
+       0x16, 0xa5, 0x24, 0x9e, 0xf3, 0xfd, 0xcb, 0xa5,
+       0xe6, 0xa6, 0xf3, 0x94, 0x06, 0x85, 0x86, 0x91,
+       0xad, 0x81, 0x8b, 0xaa, 0x24, 0xf4, 0x18, 0x93,
+       0x5a, 0x1a, 0x2e, 0xf2, 0x98, 0x05, 0x63, 0x8d,
+       0x6a, 0x22, 0x52, 0x76, 0x18, 0xe2, 0x87, 0x50,
+       0x62, 0x6c, 0x08, 0x25, 0xc6, 0x34, 0xca, 0x4f,
+       0xfb, 0xf6, 0x3b, 0x0d, 0x13, 0x1a, 0x57, 0x7c,
+       0x02, 0x6a, 0xcc, 0x63, 0x48, 0x1b, 0x12, 0xeb,
+       0x34, 0xdc, 0xab, 0xc5, 0x22, 0x7d, 0x95, 0xb5,
+       0x86, 0xf4, 0xf6, 0x96, 0xe6, 0xdf, 0xf2, 0x98,
+       0xc7, 0x6c, 0x78, 0xa8, 0xb9, 0xa9, 0x65, 0x29,
+       0x8a, 0x9a, 0xd2, 0xaa, 0x0c, 0xf7, 0x61, 0x4c,
+       0x4b, 0xf3, 0x18, 0xb2, 0xea, 0x96, 0xfa, 0xaf,
+       0x31, 0x2e, 0xbd, 0x6b, 0x9c, 0x86, 0xe9, 0x7e,
+       0xa9, 0xfe, 0xb7, 0x6a, 0x2c, 0x64, 0x98, 0xde,
+       0xde, 0xe2, 0xe7, 0x94, 0xbd, 0x95, 0x4e, 0x43,
+       0x72, 0x30, 0x20, 0x31, 0xc9, 0x7f, 0x0a, 0x7e,
+       0xf4, 0xc3, 0xa9, 0x53, 0x3e, 0x65, 0xf5, 0xec,
+       0x03, 0xc3, 0xc2, 0x66, 0x7f, 0x5b, 0x90, 0xfa,
+       0x05, 0xb5, 0x20, 0x60, 0x18, 0xc5, 0xc3, 0x2c,
+       0x16, 0x34, 0x8c, 0x0a, 0x04, 0x99, 0x12, 0xc0,
+       0x17, 0x11, 0xeb, 0x80, 0x31, 0xb7, 0x5e, 0x6a,
+       0xcb, 0x79, 0x8d, 0x97, 0xee, 0x34, 0xdc, 0xdd,
+       0xf6, 0x04, 0xe7, 0x19, 0xe9, 0x2b, 0x0b, 0x1b,
+       0xee, 0x6e, 0x5c, 0x11, 0x3c, 0xc7, 0x62, 0x7b,
+       0x3c, 0x21, 0x1d, 0xc6, 0xae, 0xf1, 0x16, 0xf5,
+       0x9a, 0xc2, 0x86, 0xfc, 0x40, 0xf0, 0x77, 0x3c,
+       0x76, 0xa3, 0x77, 0x95, 0xd1, 0xe7, 0x57, 0x2b,
+       0x83, 0xfd, 0xd0, 0x61, 0x9c, 0x13, 0x8d, 0xdd,
+       0xb8, 0xba, 0xca, 0xe8, 0x92, 0xa3, 0x69, 0x57,
+       0x3b, 0x8c, 0x4e, 0x2d, 0xd6, 0x7b, 0xa3, 0xaa,
+       0xdf, 0x58, 0xa0, 0xb5, 0xa1, 0x37, 0x52, 0x35,
+       0x60, 0x7c, 0x50, 0x8b, 0x61, 0x3d, 0x97, 0x1b,
+       0x75, 0x18, 0xf3, 0x5f, 0xa7, 0xd8, 0x8c, 0x6b,
+       0x76, 0x43, 0x45, 0x7d, 0x53, 0xcb, 0xf2, 0x8f,
+       0x28, 0x56, 0x70, 0xcd, 0x6c, 0x98, 0x45, 0xb1,
+       0xcb, 0x3c, 0x66, 0xe3, 0xb1, 0x5e, 0x4e, 0x59,
+       0x80, 0x94, 0x7e, 0xa6, 0x66, 0x94, 0x96, 0x81,
+       0x69, 0x14, 0xbb, 0xcc, 0x62, 0x0e, 0x35, 0x46,
+       0x72, 0xe9, 0xbb, 0x2e, 0x18, 0x2a, 0x49, 0x66,
+       0xd9, 0xbb, 0x31, 0x76, 0xf6, 0x3a, 0x18, 0x16,
+       0x68, 0xb1, 0x4f, 0x0b, 0x5e, 0x37, 0xc3, 0xb8,
+       0xfa, 0x65, 0xfe, 0xdf, 0x71, 0xc9, 0xef, 0x07,
+       0x83, 0x20, 0xd5, 0xd5, 0x9f, 0x57, 0xfb, 0x01,
+       0x63, 0x6d, 0x5a, 0xcc, 0xf1, 0x3e, 0x40, 0x92,
+       0xd4, 0xd0, 0xd0, 0xc7, 0x63, 0xcf, 0x61, 0xac,
+       0xad, 0xbd, 0xae, 0x8f, 0x8f, 0x2a, 0xd4, 0xc1,
+       0x99, 0x7e, 0x62, 0x2a, 0x9f, 0xe7, 0xb1, 0x52,
+       0x8a, 0x7d, 0xac, 0xa6, 0x19, 0xbd, 0xfe, 0xe6,
+       0x56, 0xe9, 0xbc, 0x16, 0x2b, 0x27, 0x4d, 0x66,
+       0x23, 0x3c, 0xdc, 0x13, 0x36, 0xdc, 0x5f, 0x27,
+       0x07, 0xd5, 0xd8, 0x25, 0x16, 0xab, 0x5f, 0xfc,
+       0x09, 0x8b, 0x5d, 0xe6, 0xb1, 0xe6, 0xab, 0x2c,
+       0x76, 0x85, 0xc5, 0x54, 0xcb, 0x10, 0xbe, 0x18,
+       0x36, 0x64, 0xd6, 0xc9, 0xd8, 0x67, 0x9f, 0x51,
+       0xec, 0xb7, 0x5a, 0xec, 0x0f, 0x14, 0xfb, 0x1d,
+       0x8b, 0xc9, 0xf2, 0xef, 0x19, 0xe5, 0xef, 0xc3,
+       0x86, 0xc9, 0x75, 0x72, 0x53, 0xcb, 0x1f, 0x58,
+       0x0c, 0x7b, 0x33, 0xbb, 0x5e, 0x6a, 0x6e, 0xfe,
+       0x1d, 0x8b, 0x39, 0xc3, 0x86, 0x18, 0xb5, 0x9a,
+       0x18, 0x73, 0x87, 0x0d, 0x13, 0x07, 0x63, 0xc5,
+       0x61, 0x83, 0x61, 0x30, 0x56, 0x1a, 0x36, 0x18,
+       0xa3, 0xb1, 0xde, 0x4a, 0xd1, 0x90, 0x12, 0x8d,
+       0xdd, 0xa8, 0x5c, 0x65, 0xc8, 0xa0, 0xa6, 0xff,
+       0x06, 0x63, 0x7f, 0x0a, 0xa1, 0xf6, 0xa4, 0x52,
+       0x8c, 0x4a, 0xf8, 0xb4, 0x40, 0x67, 0xd6, 0x8d,
+       0xa7, 0x18, 0xeb, 0xb1, 0x70, 0x1f, 0x18, 0x1f,
+       0x09, 0xd6, 0x5d, 0xe6, 0x23, 0x27, 0xec, 0x0a,
+       0x1b, 0x2c, 0xcd, 0x8d, 0x1f, 0xa9, 0xe3, 0x4f,
+       0x8c, 0x18, 0xa6, 0xd4, 0x05, 0xa4, 0x2c, 0xd6,
+       0xd3, 0x11, 0x89, 0x62, 0x6d, 0x01, 0x35, 0x86,
+       0x1e, 0x9d, 0x89, 0xd2, 0xfe, 0xc8, 0xd3, 0x28,
+       0x86, 0x69, 0x2c, 0x06, 0x98, 0x66, 0xa6, 0xb4,
+       0x73, 0xc3, 0x62, 0xac, 0xb5, 0x40, 0xa7, 0xeb,
+       0x13, 0xe5, 0xb9, 0x61, 0x31, 0x96, 0xd6, 0xd5,
+       0x1b, 0x32, 0x56, 0xfb, 0xcf, 0xa9, 0x56, 0x71,
+       0x2b, 0x5a, 0xb7, 0x1a, 0x59, 0x8d, 0xf5, 0x62,
+       0x5d, 0x8c, 0x0e, 0x35, 0x42, 0x31, 0x30, 0xc6,
+       0x46, 0x63, 0x58, 0x82, 0x31, 0x4e, 0x8b, 0x45,
+       0xfa, 0x7a, 0x3d, 0xc6, 0x2a, 0x7f, 0xc3, 0x39,
+       0xd5, 0xb6, 0xf6, 0x3a, 0x8d, 0xb3, 0xfd, 0x7f,
+       0xd0, 0xd2, 0xae, 0x7a, 0x8c, 0x6e, 0x39, 0x9a,
+       0x76, 0xd5, 0x69, 0x2c, 0x92, 0xd5, 0xb4, 0xde,
+       0xbe, 0xaa, 0xc3, 0x46, 0x5b, 0x83, 0x56, 0x5e,
+       0xb8, 0x2a, 0x6c, 0x4c, 0xf8, 0x43, 0xd4, 0x42,
+       0x7b, 0xc0, 0x30, 0xa6, 0x45, 0xd5, 0x3a, 0x8c,
+       0x39, 0x0d, 0x63, 0xfc, 0x9a, 0x94, 0xc2, 0xde,
+       0xb0, 0x61, 0x4c, 0x50, 0x52, 0xad, 0x7e, 0xb8,
+       0x32, 0x64, 0x18, 0xb3, 0xa4, 0xed, 0xaa, 0x16,
+       0xc3, 0xb4, 0x25, 0xcb, 0xd4, 0xd9, 0x22, 0x7c,
+       0x16, 0x63, 0x52, 0x34, 0xed, 0x23, 0x16, 0xbb,
+       0xac, 0xc6, 0xce, 0x61, 0xac, 0x39, 0x9a, 0xf6,
+       0x1b, 0x16, 0xd3, 0xd2, 0xce, 0x63, 0x2c, 0xd0,
+       0xba, 0xe2, 0x2a, 0x8f, 0x7d, 0xcc, 0x63, 0x97,
+       0x79, 0xec, 0x02, 0x8b, 0x69, 0xf9, 0x3e, 0x61,
+       0x31, 0x2d, 0xdf, 0xa7, 0x58, 0x6b, 0x7f, 0x9b,
+       0xa4, 0xea, 0xfc, 0xa7, 0x54, 0x6b, 0x9c, 0xc8,
+       0x82, 0xad, 0x81, 0x8f, 0x23, 0xe1, 0x3f, 0x60,
+       0x9a, 0x1c, 0x4d, 0xfb, 0x03, 0xa6, 0xc9, 0xd1,
+       0xb4, 0x0a, 0xa7, 0xa1, 0xb0, 0xa1, 0x69, 0x79,
+       0x7b, 0x33, 0x9b, 0x8f, 0x30, 0x36, 0x0d, 0x63,
+       0x6d, 0xd1, 0xd8, 0x54, 0x4a, 0x63, 0xf6, 0x93,
+       0x62, 0x0f, 0x53, 0x9a, 0x1a, 0x03, 0xc3, 0xd4,
+       0x65, 0xed, 0xcd, 0xed, 0xd1, 0xd8, 0xc3, 0x18,
+       0x63, 0x69, 0x9f, 0x86, 0x43, 0x61, 0xc3, 0x08,
+       0xa4, 0xfc, 0x8c, 0xeb, 0xd9, 0x1a, 0x1e, 0xfb,
+       0x03, 0x8f, 0x85, 0x31, 0x86, 0x94, 0x6a, 0xda,
+       0x7e, 0x1e, 0x53, 0xd3, 0x5c, 0x21, 0xc3, 0x88,
+       0xfa, 0xc5, 0x4b, 0x99, 0x66, 0x61, 0x0c, 0x0c,
+       0x33, 0x28, 0x76, 0x99, 0xf5, 0xd1, 0x86, 0xb0,
+       0xfe, 0x0e, 0x1c, 0xef, 0x1f, 0xf1, 0x1e, 0xeb,
+       0xc2, 0x18, 0x5a, 0x0d, 0x35, 0xd6, 0x8d, 0x31,
+       0xb4, 0x0c, 0x1f, 0x71, 0x0b, 0x1d, 0x02, 0x48,
+       0x54, 0x85, 0x84, 0xb1, 0x0d, 0x18, 0x6b, 0x6b,
+       0x3f, 0xa7, 0xc6, 0xba, 0x30, 0x56, 0xaf, 0xf6,
+       0xd1, 0xa7, 0x10, 0xc6, 0x98, 0xc4, 0xa7, 0x69,
+       0x8c, 0x75, 0x53, 0xac, 0x41, 0x8b, 0xad, 0x41,
+       0xcf, 0x66, 0x90, 0x0b, 0x5a, 0x1b, 0xeb, 0x20,
+       0x97, 0xd7, 0x31, 0xd6, 0xa8, 0x26, 0x7e, 0x0a,
+       0xfb, 0x31, 0x36, 0xc8, 0xe5, 0x7d, 0x8a, 0xa9,
+       0x5c, 0x22, 0x61, 0x33, 0x18, 0x46, 0xd7, 0x71,
+       0xf3, 0x42, 0x31, 0x27, 0xc6, 0xb8, 0x79, 0xa1,
+       0x58, 0x88, 0x62, 0xcd, 0x6a, 0x4f, 0x9b, 0xc3,
+       0x18, 0xe3, 0xe6, 0x05, 0x3e, 0xc7, 0x58, 0x4c,
+       0x4e, 0xbd, 0xaa, 0x67, 0x9f, 0x87, 0x21, 0x6c,
+       0xca, 0x43, 0x49, 0xec, 0x8c, 0xc6, 0x1e, 0xc0,
+       0xb6, 0xef, 0xe4, 0xe5, 0x55, 0x01, 0xd8, 0xb1,
+       0xed, 0x9f, 0xf2, 0xd8, 0x1c, 0x8c, 0xa1, 0x94,
+       0x78, 0xcc, 0x7e, 0x16, 0xe0, 0x2e, 0x4d, 0x07,
+       0x31, 0x66, 0x86, 0xbb, 0x9a, 0x07, 0x63, 0x36,
+       0xb8, 0x4b, 0xd3, 0x33, 0x8c, 0xd9, 0x29, 0xa6,
+       0xa5, 0x7d, 0xc4, 0xf2, 0x5d, 0xd6, 0x62, 0x2c,
+       0x5f, 0x34, 0xc6, 0xf3, 0x5d, 0x56, 0x63, 0x2c,
+       0x9f, 0xaa, 0x83, 0x74, 0xb9, 0x33, 0x3a, 0xa3,
+       0xd3, 0x29, 0x6b, 0x77, 0x46, 0x67, 0x74, 0xfa,
+       0x58, 0xc6, 0x9d, 0x58, 0x33, 0x35, 0x66, 0xa2,
+       0xb4, 0x06, 0x2d, 0xcd, 0x82, 0xb1, 0xa8, 0x5f,
+       0x80, 0x0e, 0x25, 0xdc, 0x89, 0xed, 0xe3, 0x73,
+       0x7f, 0x58, 0x07, 0x06, 0xab, 0x26, 0x41, 0x8c,
+       0x39, 0x31, 0xa6, 0x4a, 0x10, 0x63, 0x21, 0x8a,
+       0x71, 0x09, 0x62, 0x2c, 0x8c, 0x31, 0x55, 0x82,
+       0x11, 0x74, 0x4a, 0x61, 0x12, 0x59, 0x3e, 0x6e,
+       0x89, 0x9c, 0x00, 0x63, 0x5a, 0x1a, 0x15, 0x3e,
+       0x5b, 0xe0, 0xb2, 0x07, 0xc6, 0xa8, 0xd9, 0x30,
+       0x56, 0xcc, 0xd2, 0x54, 0x0f, 0x02, 0x4a, 0x29,
+       0xd6, 0xaa, 0xce, 0xbe, 0xe0, 0xc5, 0x98, 0x5a,
+       0x38, 0x69, 0x0b, 0x18, 0xef, 0x21, 0x9e, 0xaf,
+       0x31, 0x4b, 0xb4, 0x15, 0x0c, 0x7a, 0xf4, 0x27,
+       0x1a, 0x27, 0x7f, 0x44, 0xb1, 0x5e, 0x2d, 0xa6,
+       0xba, 0x7a, 0x06, 0x7d, 0x43, 0x3d, 0x53, 0x64,
+       0x90, 0xbc, 0xec, 0x99, 0xac, 0x4e, 0x74, 0x4b,
+       0x39, 0x6a, 0x88, 0xee, 0x72, 0xa5, 0x79, 0x3e,
+       0x39, 0x0b, 0x41, 0xe8, 0xd9, 0x2c, 0xe6, 0x45,
+       0x63, 0xba, 0xb3, 0x9b, 0xc5, 0xf4, 0x68, 0xcc,
+       0xe0, 0x71, 0x8a, 0xf6, 0x68, 0x2c, 0xe6, 0xa3,
+       0x4e, 0xf6, 0x6c, 0x94, 0xc7, 0x62, 0x2f, 0x6e,
+       0x0e, 0x8c, 0x3a, 0xe0, 0xb4, 0xfd, 0xc9, 0x66,
+       0xa5, 0x93, 0x2e, 0x2a, 0xce, 0x00, 0xae, 0x29,
+       0x1c, 0xd9, 0x39, 0xb9, 0x79, 0x0f, 0xe4, 0x3f,
+       0x58, 0xf0, 0x10, 0xce, 0xa1, 0x0d, 0x8d, 0xb2,
+       0xe7, 0x93, 0x5e, 0x08, 0xc6, 0x75, 0xad, 0xad,
+       0xa7, 0x15, 0x63, 0x9a, 0xdb, 0xa0, 0xe5, 0x92,
+       0xcd, 0x5e, 0x5c, 0x6d, 0x7b, 0x0d, 0x8a, 0xa9,
+       0xea, 0x2d, 0xe4, 0x70, 0x84, 0xbe, 0x61, 0x81,
+       0x1c, 0x46, 0xd1, 0x1a, 0x80, 0xbe, 0x46, 0x66,
+       0xe8, 0xe1, 0x2b, 0x2f, 0x76, 0xb6, 0xe9, 0x00,
+       0x34, 0xa8, 0xeb, 0x30, 0xa7, 0xa8, 0x9f, 0x02,
+       0xb8, 0x02, 0xad, 0xaf, 0xd7, 0xfb, 0xeb, 0x69,
+       0x35, 0x47, 0x7b, 0x4c, 0x44, 0xeb, 0x14, 0xf0,
+       0x8f, 0x0a, 0xff, 0x1d, 0x85, 0x15, 0x93, 0x46,
+       0xc9, 0xa1, 0xc0, 0xdf, 0x1e, 0x70, 0x16, 0xf5,
+       0xc3, 0xa4, 0x40, 0x9c, 0xdb, 0x18, 0x74, 0xa4,
+       0xdf, 0xd5, 0xf5, 0x54, 0xa3, 0xb9, 0xea, 0xe0,
+       0x86, 0xa7, 0x7c, 0x7a, 0x91, 0xbe, 0x58, 0x6a,
+       0xa4, 0x2f, 0x95, 0xda, 0x0e, 0xcc, 0x79, 0x37,
+       0x72, 0x9e, 0x7f, 0x4d, 0xe9, 0xeb, 0x7e, 0x4b,
+       0x49, 0xfd, 0x5e, 0x45, 0xbc, 0x64, 0x95, 0x2c,
+       0x55, 0x07, 0xb5, 0x77, 0x15, 0x3e, 0xda, 0x9c,
+       0x04, 0x32, 0xf1, 0x4c, 0xaa, 0x3a, 0x18, 0x8c,
+       0x0d, 0x38, 0x3e, 0x30, 0x34, 0xe8, 0x03, 0xd9,
+       0x36, 0x7a, 0x67, 0xe8, 0x1a, 0xdd, 0x77, 0xac,
+       0x6c, 0xb7, 0x8e, 0x81, 0x34, 0x59, 0xef, 0x2b,
+       0x0f, 0xc6, 0x8a, 0x49, 0xd1, 0xb0, 0x41, 0xb4,
+       0x44, 0xc3, 0x3a, 0x3f, 0x24, 0x8c, 0xd9, 0x59,
+       0x08, 0x72, 0x9d, 0xb0, 0x11, 0x5b, 0xd1, 0x98,
+       0xbc, 0x93, 0xbe, 0xfa, 0x44, 0x5f, 0x95, 0xce,
+       0x6e, 0x8c, 0x47, 0xcc, 0x7d, 0x17, 0x3b, 0x43,
+       0x3a, 0x5f, 0x39, 0x72, 0x3c, 0x45, 0x67, 0x63,
+       0x12, 0x35, 0xa3, 0x13, 0x88, 0xae, 0x2e, 0xd9,
+       0x57, 0x6e, 0xd3, 0xa9, 0x98, 0x78, 0x86, 0x31,
+       0xfb, 0xca, 0xc3, 0x28, 0x9b, 0x6e, 0x9d, 0x17,
+       0x88, 0x3a, 0x80, 0x3d, 0xa2, 0xa6, 0x27, 0xb1,
+       0x74, 0x9b, 0xaf, 0xbc, 0x3b, 0x34, 0x05, 0x3e,
+       0xee, 0xec, 0xfe, 0xc7, 0xee, 0x35, 0xc8, 0xf5,
+       0x7c, 0x65, 0x7b, 0x57, 0x5b, 0x53, 0x4b, 0x7d,
+       0xeb, 0x1f, 0xec, 0x52, 0x1d, 0x69, 0x6f, 0x6d,
+       0x1b, 0x83, 0x8b, 0x1a, 0x18, 0x48, 0x91, 0x30,
+       0x05, 0x60, 0x3b, 0xb7, 0x31, 0xe7, 0xda, 0x18,
+       0xbc, 0xd0, 0xc0, 0x80, 0x55, 0x6a, 0x6b, 0xba,
+       0x82, 0xf2, 0x91, 0x82, 0x12, 0x82, 0x91, 0x08,
+       0x5a, 0x7a, 0x60, 0x0f, 0xb7, 0x77, 0xf7, 0xb0,
+       0x6c, 0x70, 0x57, 0x7d, 0x2b, 0x79, 0xed, 0x5b,
+       0x1b, 0x9a, 0xc8, 0xdd, 0x3b, 0xdb, 0xc6, 0xe0,
+       0xf9, 0x06, 0x06, 0x6c, 0x8d, 0xc1, 0x56, 0x1c,
+       0x21, 0x63, 0x95, 0xc6, 0x60, 0xe3, 0x8a, 0xde,
+       0x71, 0x08, 0x96, 0x49, 0x57, 0x74, 0x4d, 0x2d,
+       0xa4, 0xfe, 0x86, 0xa6, 0x96, 0x60, 0xa0, 0x1f,
+       0xee, 0x68, 0x6e, 0x55, 0xb2, 0xbb, 0x20, 0x09,
+       0x01, 0xda, 0x9f, 0x44, 0x04, 0x58, 0x90, 0x09,
+       0x41, 0x8b, 0xff, 0xf5, 0x6d, 0xcb, 0x5a, 0xa9,
+       0x4a, 0x21, 0xee, 0x99, 0x84, 0xdb, 0x18, 0x3c,
+       0xd8, 0xc0, 0xc0, 0x3f, 0x2d, 0x6b, 0x27, 0x23,
+       0xf1, 0x9b, 0x36, 0x06, 0x3f, 0x69, 0x60, 0x20,
+       0x99, 0x8f, 0xba, 0x85, 0x6d, 0x0c, 0x3e, 0xd6,
+       0xc0, 0xc0, 0xff, 0x0c, 0x30, 0xd7, 0xe5, 0xe5,
+       0x36, 0x74, 0x93, 0x3e, 0x86, 0x97, 0xda, 0x94,
+       0x66, 0xac, 0xdb, 0x3f, 0x23, 0xc0, 0x2c, 0xf1,
+       0xac, 0x79, 0xa0, 0x47, 0xf1, 0x60, 0x1b, 0x8c,
+       0x6d, 0xdf, 0x08, 0x60, 0xd5, 0x5c, 0x6d, 0x0c,
+       0x96, 0x34, 0x30, 0xb0, 0x83, 0x5b, 0xe9, 0x9e,
+       0x36, 0x06, 0x2f, 0x37, 0x30, 0x30, 0x8a, 0xc9,
+       0x03, 0xe2, 0x98, 0x3c, 0x20, 0x21, 0xd8, 0xd8,
+       0x82, 0x0d, 0x9d, 0xca, 0xc7, 0xf5, 0xe8, 0xe0,
+       0x13, 0xad, 0xd4, 0xec, 0x20, 0xc8, 0xb0, 0xb8,
+       0xa9, 0xb9, 0xad, 0xbe, 0xbe, 0x1e, 0xeb, 0xd3,
+       0xf8, 0x8d, 0xe5, 0xf5, 0xcb, 0xdb, 0xfc, 0xcd,
+       0xcb, 0x9a, 0x94, 0xc6, 0xe6, 0xa0, 0x12, 0x6c,
+       0x6e, 0xac, 0x43, 0x47, 0xb4, 0xb9, 0xad, 0xb9,
+       0xbe, 0xad, 0x0d, 0x6b, 0xd6, 0x26, 0xd5, 0x3f,
+       0xd1, 0xf6, 0x44, 0x7d, 0x53, 0x5b, 0x53, 0xbd,
+       0xd2, 0xa6, 0x60, 0x8e, 0xfa, 0x7a, 0x19, 0x79,
+       0x35, 0x7e, 0x03, 0xa0, 0x55, 0x09, 0xe2, 0xaf,
+       0x11, 0x5a, 0x9b, 0x11, 0x36, 0x23, 0x54, 0x9a,
+       0xa1, 0x35, 0x00, 0xd0, 0xde, 0x82, 0x3f, 0x24,
+       0x68, 0xc7, 0xf4, 0x76, 0x4c, 0x6f, 0xc7, 0xf4,
+       0x76, 0x4c, 0x6f, 0x69, 0x04, 0x2c, 0x1b, 0xa0,
+       0x0d, 0x19, 0xb4, 0x61, 0x3a, 0x26, 0x03, 0x26,
+       0x03, 0x26, 0x03, 0x26, 0x03, 0x66, 0xc7, 0x1f,
+       0xd2, 0x29, 0xb4, 0x85, 0xa8, 0x19, 0x5a, 0x28,
+       0x8c, 0x89, 0x2d, 0x0a, 0xe1, 0x82, 0x80, 0x95,
+       0x85, 0x36, 0xa4, 0xcd, 0x7e, 0xbb, 0xea, 0x62,
+       0x05, 0x76, 0x8e, 0x23, 0x23, 0xe7, 0xfb, 0x1f,
+       0x63, 0x20, 0x27, 0xa3, 0xf1, 0xfb, 0x3c, 0xde,
+       0xf8, 0x7d, 0x47, 0x56, 0x57, 0x73, 0x0b, 0xe2,
+       0xf1, 0x92, 0xed, 0xf8, 0xfe, 0xeb, 0xd9, 0x5d,
+       0xd9, 0x8e, 0xae, 0xf6, 0xb6, 0xde, 0xcc, 0xfa,
+       0xfa, 0xab, 0x99, 0x6d, 0x57, 0x27, 0x66, 0x4e,
+       0xde, 0x31, 0xf1, 0xfe, 0xcc, 0x1d, 0x66, 0xb3,
+       0xbf, 0x3e, 0x00, 0xe6, 0xd8, 0xb6, 0x80, 0x1f,
+       0xcc, 0xa6, 0x76, 0xba, 0xc6, 0x2c, 0x5b, 0xd6,
+       0x1e, 0x30, 0x1b, 0x9b, 0xda, 0x30, 0x6c, 0x58,
+       0x46, 0x57, 0x7d, 0xbd, 0x24, 0x05, 0xcc, 0xba,
+       0xe5, 0x75, 0x48, 0x09, 0xed, 0x88, 0x01, 0x73,
+       0x5d, 0x7b, 0x5b, 0x00, 0x62, 0x1b, 0x82, 0xc1,
+       0x6c, 0x30, 0xe1, 0xd5, 0x01, 0x31, 0x4d, 0x14,
+       0x36, 0x36, 0x51, 0xd8, 0x10, 0xac, 0xa7, 0x1e,
+       0xab, 0x97, 0x90, 0xb5, 0xae, 0x41, 0xae, 0x67,
+       0x2d, 0xad, 0x87, 0x90, 0x39, 0x18, 0xec, 0xb2,
+       0x06, 0x83, 0xaf, 0x3b, 0x83, 0xbf, 0x29, 0x6e,
+       0x08, 0xf4, 0x7a, 0xda, 0x02, 0xbd, 0x15, 0xf5,
+       0x81, 0xde, 0xaa, 0x7a, 0xe9, 0x72, 0x6d, 0x5b,
+       0xfd, 0x6f, 0x16, 0x49, 0xbf, 0x11, 0xb1, 0xec,
+       0xb6, 0xab, 0xa2, 0xbf, 0xed, 0x6a, 0x83, 0xbf,
+       0xbe, 0xed, 0xea, 0xab, 0xcb, 0x71, 0x81, 0x3e,
+       0xa9, 0xae, 0xf9, 0x09, 0x03, 0xe8, 0xa3, 0xef,
+       0x78, 0xc4, 0xfc, 0x75, 0x5f, 0xfd, 0x5f, 0xff,
+       0xbe, 0xfc, 0x04, 0x86, 0x27, 0xe9, 0xeb, 0x65,
+       0xdb, 0xba, 0x43, 0xb4, 0xb7, 0x74, 0x44, 0x7f,
+       0x9a, 0xc7, 0x9b, 0xac, 0x7d, 0xa9, 0x78, 0xc4,
+       0x8d, 0x49, 0x9e, 0xd7, 0x3f, 0x27, 0x58, 0x67,
+       0xb7, 0xd9, 0x71, 0x4e, 0x5b, 0x58, 0xd7, 0x8b,
+       0x57, 0x57, 0xe3, 0x25, 0x73, 0x18, 0x62, 0x46,
+       0x3b, 0x71, 0xcd, 0x73, 0xb6, 0xac, 0xff, 0x77,
+       0xe7, 0x84, 0x59, 0x45, 0x97, 0xc1, 0x64, 0x1b,
+       0x4d, 0xa7, 0x6e, 0x75, 0xd9, 0x65, 0xd0, 0x2d,
+       0x61, 0x3b, 0x0a, 0xae, 0xd0, 0x8e, 0x5f, 0xab,
+       0xc9, 0xfd, 0x06, 0x5e, 0xf5, 0xee, 0x05, 0xee,
+       0x39, 0x8e, 0x4c, 0x3a, 0x01, 0x3c, 0x16, 0xba,
+       0x3a, 0x8c, 0xa0, 0x80, 0x2e, 0xad, 0xab, 0xc3,
+       0x40, 0xd0, 0x64, 0xb5, 0x43, 0x16, 0xe6, 0xca,
+       0xf3, 0x3a, 0xe5, 0x7c, 0xbe, 0xab, 0x0c, 0x31,
+       0x75, 0x0a, 0x5a, 0x26, 0x1f, 0x8b, 0xe5, 0xec,
+       0x03, 0xa7, 0x35, 0x03, 0x9e, 0x88, 0xd0, 0xa9,
+       0xac, 0x27, 0xa3, 0xb8, 0x10, 0xe2, 0x9a, 0x19,
+       0xee, 0x60, 0x17, 0xed, 0x92, 0x9b, 0xea, 0x56,
+       0x53, 0xf4, 0xa0, 0xe6, 0x7f, 0x55, 0xa3, 0x35,
+       0x42, 0x34, 0xff, 0x66, 0x0d, 0x67, 0x82, 0x68,
+       0xfe, 0xa7, 0xbb, 0x68, 0x6f, 0x9d, 0x63, 0x48,
+       0xd9, 0x7e, 0xdf, 0x20, 0x2f, 0x9e, 0xf3, 0xb1,
+       0x61, 0xbc, 0x28, 0x5f, 0x05, 0xed, 0x81, 0x91,
+       0x05, 0xed, 0x99, 0x1f, 0xe6, 0x7b, 0x42, 0x29,
+       0x18, 0x56, 0x63, 0xa2, 0x4a, 0xef, 0xa2, 0x3d,
+       0x7a, 0xf3, 0x86, 0x51, 0x25, 0x68, 0x54, 0x3a,
+       0x95, 0x97, 0x9c, 0x6f, 0xb5, 0x81, 0x20, 0x3b,
+       0x7c, 0x9a, 0xbc, 0xe9, 0xfb, 0xf1, 0x82, 0xd2,
+       0x5b, 0xf5, 0x4e, 0xba, 0x87, 0xa4, 0xe6, 0x09,
+       0x75, 0x3b, 0x5d, 0xfd, 0x30, 0xcf, 0xe1, 0x00,
+       0xda, 0x6d, 0x1a, 0x5f, 0x89, 0x2e, 0xba, 0x37,
+       0x56, 0x8e, 0x77, 0xc7, 0x7a, 0x37, 0x29, 0x63,
+       0xcb, 0x2e, 0x43, 0xbc, 0x08, 0x37, 0xe8, 0x4c,
+       0xe6, 0xed, 0x56, 0x73, 0x8e, 0x6d, 0x6d, 0x33,
+       0xe8, 0x1d, 0x6b, 0xe8, 0xec, 0xc8, 0x27, 0xd9,
+       0xde, 0x3d, 0xf1, 0x3a, 0xe3, 0x1e, 0xef, 0xf3,
+       0xf0, 0x90, 0x62, 0xa4, 0x10, 0x2f, 0x49, 0x3d,
+       0x6b, 0x41, 0x8f, 0xae, 0xa0, 0x00, 0x53, 0x61,
+       0x3d, 0x2c, 0x47, 0x27, 0xed, 0x03, 0x5d, 0x82,
+       0x2e, 0x4d, 0x97, 0xa7, 0x2b, 0xd4, 0xd5, 0xe8,
+       0x1e, 0x33, 0x82, 0xd1, 0x6e, 0x2c, 0x36, 0x56,
+       0xe8, 0x32, 0x8d, 0xeb, 0x46, 0x1c, 0x33, 0x3e,
+       0x6b, 0x7c, 0xd1, 0x78, 0xc8, 0x78, 0x23, 0x26,
+       0x39, 0x66, 0xac, 0x39, 0xd5, 0xbc, 0x71, 0xc4,
+       0x4b, 0x23, 0x8e, 0x59, 0x4d, 0xd6, 0x85, 0x23,
+       0x33, 0x47, 0x3a, 0x46, 0xe6, 0x8d, 0x2c, 0x18,
+       0xe9, 0x31, 0xe9, 0x21, 0xcf, 0x58, 0x65, 0xda,
+       0x6d, 0x5a, 0x65, 0xda, 0x1c, 0x9b, 0x0e, 0x87,
+       0x60, 0xa7, 0xf9, 0x80, 0xf9, 0x83, 0x38, 0x7b,
+       0xdc, 0xa6, 0xb8, 0x2d, 0x71, 0xbb, 0x2d, 0xb6,
+       0xb8, 0x0f, 0x46, 0x4e, 0x1d, 0xb1, 0x64, 0x44,
+       0xc3, 0x08, 0xc7, 0x88, 0x49, 0xb1, 0x39, 0xba,
+       0x64, 0x4b, 0x4e, 0xdc, 0x51, 0xc3, 0x75, 0xe3,
+       0x54, 0x8b, 0xdb, 0x30, 0x29, 0x66, 0x49, 0x8c,
+       0xd7, 0x52, 0x6a, 0x59, 0x64, 0xd9, 0x6b, 0xe9,
+       0x89, 0xd9, 0x17, 0x73, 0x2e, 0x76, 0x85, 0x31,
+       0xcf, 0xd0, 0x6b, 0xc9, 0x8c, 0x3b, 0x84, 0x2e,
+       0x67, 0x85, 0x65, 0x9e, 0xa5, 0xc2, 0x32, 0x36,
+       0xe6, 0x72, 0xec, 0x16, 0x5d, 0x8b, 0x6e, 0x85,
+       0xde, 0xa4, 0x5f, 0xab, 0x5f, 0xad, 0xb7, 0xd0,
+       0x73, 0xe3, 0x3f, 0x2e, 0xa2, 0x6f, 0xa2, 0x58,
+       0xcd, 0x95, 0xed, 0xda, 0xae, 0xc4, 0xf8, 0xe3,
+       0xae, 0xfe, 0xfe, 0x12, 0x11, 0xe2, 0x83, 0x83,
+       0x7b, 0x98, 0xe2, 0xdf, 0x44, 0xdc, 0x03, 0x88,
+       0x13, 0x11, 0x4e, 0xa2, 0x7d, 0xb3, 0xfd, 0x19,
+       0x88, 0xf5, 0x21, 0xe6, 0x05, 0x3a, 0xc3, 0x9c,
+       0xee, 0xd8, 0x8e, 0xbc, 0xba, 0x66, 0x25, 0x71,
+       0xb2, 0xde, 0x4d, 0x3a, 0xf9, 0xcb, 0x30, 0xc2,
+       0x27, 0x94, 0x54, 0xf3, 0xe7, 0xe8, 0x8c, 0x6f,
+       0xb7, 0xc6, 0x59, 0xef, 0x67, 0x7d, 0x5a, 0x29,
+       0x16, 0x20, 0xe5, 0x06, 0x46, 0x93, 0x45, 0x14,
+       0x32, 0xf1, 0xa1, 0xaf, 0xf3, 0x1c, 0x9e, 0x1b,
+       0xda, 0xc0, 0xf4, 0x9d, 0xae, 0x23, 0xfa, 0x53,
+       0x61, 0x89, 0xbe, 0x74, 0xcd, 0xce, 0x7d, 0x00,
+       0x4f, 0x46, 0xea, 0x8c, 0x22, 0x8c, 0x1c, 0x70,
+       0xb3, 0x6f, 0xe5, 0x8e, 0xac, 0x61, 0x79, 0xaf,
+       0xe2, 0xb5, 0x59, 0xbe, 0x8c, 0x79, 0xcd, 0x98,
+       0xf7, 0x19, 0x9e, 0x77, 0x44, 0x3f, 0xd2, 0x5d,
+       0x40, 0x1a, 0x07, 0xe7, 0xef, 0xaf, 0xdb, 0x70,
+       0x37, 0x7b, 0x8f, 0xff, 0xf7, 0x72, 0x2a, 0x62,
+       0x3f, 0x44, 0xca, 0x3a, 0x8d, 0x72, 0xcd, 0x43,
+       0x54, 0x2b, 0xc5, 0x82, 0xa5, 0x84, 0x02, 0x4f,
+       0x76, 0xad, 0xa9, 0xd7, 0xab, 0xfc, 0x4f, 0x88,
+       0x60, 0x9d, 0x7e, 0xbb, 0x7d, 0x5c, 0x23, 0xf7,
+       0x62, 0x4a, 0xbe, 0x04, 0xd6, 0xa9, 0x58, 0xca,
+       0xcb, 0x58, 0xc2, 0x04, 0x19, 0x4e, 0x9c, 0x42,
+       0x9e, 0xe9, 0x98, 0xf6, 0x98, 0xab, 0xff, 0xf3,
+       0xd1, 0x88, 0x77, 0x4a, 0x66, 0x0c, 0x8d, 0xc0,
+       0x50, 0xbe, 0x4a, 0xb1, 0x47, 0x82, 0xcf, 0xfa,
+       0x30, 0x5e, 0xe8, 0x28, 0xd4, 0x85, 0x91, 0x32,
+       0x4b, 0xbc, 0x80, 0x5e, 0x5a, 0xfb, 0xc6, 0xbb,
+       0x15, 0xeb, 0xf1, 0x42, 0xb8, 0x81, 0x14, 0xcf,
+       0xa3, 0x4d, 0x18, 0x81, 0xfe, 0x61, 0x8b, 0x6c,
+       0xc2, 0x90, 0xc5, 0x57, 0xce, 0x25, 0x78, 0x62,
+       0x75, 0xa0, 0x0e, 0xa9, 0x92, 0x10, 0x67, 0x42,
+       0x4f, 0xee, 0xb7, 0x8a, 0x15, 0xaf, 0xd7, 0x11,
+       0x2f, 0xa3, 0x83, 0x8a, 0x9c, 0xac, 0xe7, 0xe9,
+       0x3c, 0x4c, 0xa4, 0x6d, 0x90, 0xed, 0x12, 0x8c,
+       0xb8, 0x8c, 0xa1, 0xa9, 0x98, 0xea, 0x91, 0x20,
+       0x36, 0x95, 0xb5, 0x6e, 0x84, 0x18, 0x5f, 0x5d,
+       0x8e, 0x34, 0x7a, 0xec, 0x03, 0xf4, 0xe8, 0xac,
+       0x44, 0x9b, 0x89, 0x14, 0x58, 0xdf, 0x58, 0xb8,
+       0x58, 0xcb, 0x68, 0x2c, 0xf4, 0x7c, 0x87, 0xfc,
+       0x46, 0xe4, 0xb7, 0x09, 0xeb, 0xd0, 0xa0, 0x90,
+       0xd7, 0x2a, 0xb3, 0x73, 0x2d, 0x8f, 0x70, 0xfa,
+       0x5f, 0x5c, 0x17, 0x41, 0x57, 0x60, 0xa6, 0x33,
+       0x60, 0x91, 0x5e, 0x02, 0x5d, 0x26, 0xa6, 0xbd,
+       0xec, 0x2f, 0x08, 0xb3, 0xde, 0x56, 0xe0, 0x17,
+       0x74, 0xa6, 0x02, 0xc1, 0x63, 0x08, 0x0b, 0x11,
+       0x1e, 0x62, 0xef, 0xdf, 0x8f, 0x4d, 0x60, 0x75,
+       0xf0, 0xc7, 0x9e, 0x8b, 0xfb, 0x4d, 0x02, 0x9d,
+       0x92, 0x32, 0xe6, 0x00, 0xc5, 0xcd, 0x6f, 0xd0,
+       0xf7, 0x81, 0xa8, 0x5c, 0xbe, 0x03, 0x72, 0x05,
+       0x38, 0x0a, 0x43, 0x54, 0x7a, 0x92, 0x26, 0x73,
+       0xcf, 0x2a, 0x58, 0x42, 0x75, 0x90, 0xe3, 0xa3,
+       0x65, 0xe2, 0x18, 0xb5, 0xe6, 0x21, 0x4d, 0x01,
+       0xab, 0x51, 0x0b, 0x5e, 0x65, 0x79, 0x31, 0x5e,
+       0xfd, 0x72, 0x5d, 0xd0, 0x8a, 0xb4, 0xf5, 0x4a,
+       0x52, 0x90, 0x24, 0xd8, 0xa6, 0xc4, 0x07, 0xa9,
+       0x95, 0x4d, 0xb2, 0x17, 0x63, 0x92, 0x5c, 0xcc,
+       0x64, 0x19, 0x90, 0x0b, 0x63, 0x68, 0x7c, 0x5b,
+       0x7c, 0x46, 0xc4, 0x4e, 0xc1, 0xd5, 0x49, 0x8c,
+       0x32, 0xc9, 0x57, 0x2e, 0xee, 0xc1, 0x76, 0x17,
+       0x84, 0x99, 0x1e, 0xc8, 0xb4, 0x1b, 0x55, 0x27,
+       0x27, 0xce, 0x01, 0x39, 0x81, 0x85, 0xf8, 0xf7,
+       0x86, 0x30, 0x8f, 0xcc, 0xf4, 0x82, 0xf7, 0xe5,
+       0x71, 0xd4, 0xb7, 0x6b, 0x05, 0xca, 0x58, 0x6c,
+       0xdf, 0x8c, 0x3a, 0x38, 0xfe, 0x21, 0xdf, 0xf1,
+       0x78, 0x9c, 0xda, 0x3f, 0xaa, 0x9e, 0x9e, 0x3d,
+       0x3a, 0x30, 0x76, 0x38, 0xd4, 0xb1, 0x88, 0xce,
+       0x9d, 0xae, 0x10, 0xc1, 0x12, 0x70, 0x14, 0x76,
+       0x03, 0x49, 0x55, 0xb6, 0xa3, 0xdf, 0x7e, 0xf7,
+       0x06, 0xa2, 0x58, 0x8e, 0x74, 0xb1, 0x75, 0xfe,
+       0x8b, 0x66, 0xea, 0x75, 0x51, 0x64, 0x6d, 0xa9,
+       0x63, 0x6d, 0x59, 0x94, 0x70, 0x37, 0xf3, 0xdb,
+       0x6b, 0x76, 0x12, 0x45, 0xe5, 0xf2, 0xd8, 0xe7,
+       0x75, 0xb1, 0x61, 0xcc, 0x9d, 0xa9, 0x4c, 0xc5,
+       0xf4, 0x29, 0xca, 0x09, 0x1c, 0x43, 0x93, 0xd1,
+       0xe2, 0x65, 0xb2, 0x3c, 0x59, 0x2c, 0x4f, 0x46,
+       0xe2, 0xdd, 0x9b, 0xd8, 0xea, 0x60, 0x17, 0xe5,
+       0x49, 0xde, 0xa5, 0xab, 0x4f, 0xf2, 0xe9, 0x78,
+       0xce, 0x5d, 0x3a, 0xf9, 0x9a, 0x18, 0x66, 0x63,
+       0xd2, 0x42, 0xfb, 0x74, 0x8f, 0x67, 0x49, 0x60,
+       0xe9, 0xa0, 0x91, 0x6a, 0x41, 0x1d, 0xb1, 0xbc,
+       0xcc, 0x42, 0x74, 0x6e, 0xe6, 0x21, 0x09, 0xe2,
+       0x48, 0x9f, 0x33, 0x15, 0x18, 0x58, 0x31, 0xd8,
+       0xda, 0xf7, 0x6f, 0x48, 0xf0, 0x07, 0x3a, 0xe7,
+       0x60, 0x5c, 0x1d, 0xbc, 0x7f, 0x15, 0xe9, 0x82,
+       0xd8, 0xa2, 0xd7, 0x10, 0x16, 0xb0, 0x9c, 0xf4,
+       0x63, 0x4f, 0x77, 0xe2, 0x0e, 0x60, 0x68, 0x2d,
+       0xa6, 0x6d, 0x41, 0x58, 0xb5, 0x1c, 0xb0, 0x96,
+       0x99, 0xa0, 0x97, 0x6d, 0xe6, 0xb7, 0x60, 0x04,
+       0x6a, 0x4b, 0xbf, 0x0f, 0x75, 0xd0, 0xb2, 0x5a,
+       0x44, 0x8d, 0xb2, 0xac, 0xe0, 0x1a, 0xf5, 0xfe,
+       0x4b, 0x74, 0xe6, 0x63, 0xee, 0x5b, 0xbc, 0x66,
+       0x88, 0x17, 0x45, 0x30, 0x1f, 0xc1, 0x96, 0x52,
+       0xa9, 0x9d, 0xc4, 0x05, 0xb9, 0x15, 0xab, 0xb5,
+       0x58, 0x21, 0xc1, 0xd5, 0xa3, 0x0a, 0xbc, 0xef,
+       0x27, 0x2d, 0xc3, 0x9a, 0x2c, 0xc6, 0x1e, 0x81,
+       0x6e, 0x60, 0xda, 0x6b, 0x46, 0xba, 0x14, 0x46,
+       0x27, 0x20, 0xd5, 0xcb, 0x48, 0xe5, 0x55, 0xa9,
+       0xdc, 0xc3, 0xa9, 0xcc, 0x6f, 0xaa, 0xba, 0x14,
+       0x47, 0x23, 0xc2, 0xbc, 0x02, 0x31, 0xaf, 0xaa,
+       0xfc, 0x71, 0xec, 0x5c, 0x7d, 0x81, 0xef, 0x61,
+       0x7d, 0xdf, 0xca, 0xad, 0x02, 0x49, 0xcb, 0xbc,
+       0xc9, 0xd5, 0xff, 0x59, 0x21, 0x69, 0x91, 0x92,
+       0x80, 0x79, 0x0d, 0x84, 0x97, 0x12, 0xa9, 0xfe,
+       0x98, 0x26, 0x23, 0x8f, 0x3a, 0xde, 0x96, 0xee,
+       0x93, 0x22, 0xc4, 0x79, 0x1d, 0xf4, 0x3d, 0xb6,
+       0x1c, 0x07, 0x1b, 0x51, 0x6c, 0x77, 0xa1, 0x75,
+       0x70, 0x77, 0x61, 0xf7, 0x6e, 0x6c, 0x63, 0x7a,
+       0x7a, 0x99, 0xf7, 0x1d, 0x25, 0x9e, 0xde, 0xa8,
+       0x42, 0x89, 0x4d, 0x92, 0x92, 0x30, 0x57, 0x1d,
+       0x8d, 0xba, 0xb8, 0xb1, 0xf8, 0x13, 0x55, 0x5e,
+       0xcf, 0x60, 0x99, 0x33, 0x53, 0xcb, 0x13, 0xec,
+       0x0a, 0x74, 0x87, 0xfc, 0x4f, 0x86, 0x6d, 0x5d,
+       0x77, 0xcb, 0x26, 0xaf, 0x7d, 0xc9, 0x35, 0xd1,
+       0x8c, 0xd7, 0x81, 0xf4, 0x32, 0xf1, 0xfc, 0x53,
+       0xea, 0xa8, 0x4d, 0xb8, 0x1b, 0xf3, 0xd4, 0xcb,
+       0x36, 0xbf, 0xc1, 0xd5, 0xff, 0xab, 0xe7, 0x77,
+       0xd2, 0x29, 0xa8, 0x66, 0xda, 0x63, 0x2e, 0x42,
+       0x77, 0xe9, 0xef, 0x3c, 0xdc, 0x12, 0x63, 0xb9,
+       0x27, 0x55, 0xce, 0x39, 0x08, 0x33, 0x10, 0x4e,
+       0xa2, 0x7d, 0xa8, 0x18, 0x9e, 0x88, 0xe1, 0xb1,
+       0x95, 0xed, 0xcb, 0x49, 0x3b, 0x83, 0x8a, 0x3d,
+       0xda, 0x67, 0xdc, 0x52, 0xc4, 0x49, 0x6e, 0xec,
+       0xb5, 0x44, 0xd1, 0x2a, 0xd9, 0x78, 0xfe, 0x9f,
+       0x5f, 0x95, 0x1c, 0x0e, 0x03, 0xb6, 0x7c, 0x79,
+       0x49, 0xff, 0xb5, 0x9c, 0x45, 0x5e, 0x6f, 0xc2,
+       0xd2, 0x94, 0x00, 0xd8, 0x72, 0x6c, 0x7a, 0x25,
+       0xbe, 0x2b, 0xd7, 0x06, 0xf2, 0x65, 0x9f, 0x0e,
+       0xb5, 0xd6, 0x28, 0x5f, 0x5e, 0xe7, 0xfb, 0x60,
+       0x3f, 0xb7, 0x29, 0xb6, 0xbb, 0x51, 0xaa, 0x0d,
+       0x8a, 0x05, 0xf5, 0x60, 0x14, 0x3b, 0x6f, 0xe5,
+       0x92, 0x04, 0xfa, 0x0d, 0x3d, 0xb5, 0xeb, 0x9c,
+       0x58, 0xaf, 0xa9, 0x2a, 0xdf, 0x2d, 0xcc, 0x7e,
+       0xc1, 0xcf, 0x37, 0x2e, 0x07, 0xe9, 0xec, 0xb7,
+       0x55, 0x5d, 0x55, 0x71, 0xab, 0x11, 0x77, 0x54,
+       0xa5, 0x0b, 0x48, 0x66, 0x2d, 0x15, 0x5b, 0x80,
+       0x9c, 0xcc, 0x34, 0x0a, 0xbe, 0x89, 0x29, 0xb5,
+       0x52, 0x06, 0xed, 0xcc, 0xf8, 0x9d, 0x27, 0x0f,
+       0xb8, 0x05, 0xfc, 0x79, 0xa9, 0x94, 0x44, 0x98,
+       0x90, 0x1b, 0xe3, 0x7f, 0x83, 0xf1, 0x7c, 0x36,
+       0xc3, 0x59, 0xd8, 0xda, 0xbc, 0x81, 0x9e, 0xf5,
+       0xf7, 0xbe, 0xaa, 0xc0, 0xcf, 0x69, 0xf7, 0xb2,
+       0x50, 0x07, 0x3f, 0xb7, 0xa3, 0xef, 0x15, 0x53,
+       0xd9, 0x1e, 0x1d, 0x9f, 0xf0, 0x73, 0x13, 0x1b,
+       0xa1, 0x70, 0xec, 0x06, 0xf9, 0x6a, 0xda, 0x68,
+       0x38, 0xd6, 0x2b, 0x82, 0xa9, 0x13, 0x39, 0x4c,
+       0x96, 0x33, 0x99, 0x55, 0x41, 0x69, 0x1e, 0x3b,
+       0x2d, 0x81, 0x69, 0xa1, 0xab, 0xff, 0x0f, 0xd8,
+       0x87, 0xb1, 0xa5, 0x18, 0x8e, 0xe7, 0x92, 0x3d,
+       0x76, 0x50, 0xd3, 0x18, 0xda, 0xd9, 0x68, 0xf2,
+       0x4a, 0x10, 0x73, 0x83, 0xb7, 0xe3, 0xd8, 0x2b,
+       0x22, 0x7c, 0xde, 0xa3, 0xe6, 0x7e, 0x11, 0xd3,
+       0x52, 0x5c, 0xfd, 0x57, 0xd1, 0x8e, 0xc7, 0xd2,
+       0xce, 0xaa, 0xba, 0x9e, 0x5a, 0xfa, 0x26, 0xad,
+       0x08, 0xb1, 0x16, 0xec, 0x0f, 0x44, 0xc8, 0x55,
+       0x2a, 0x65, 0x10, 0x39, 0x5c, 0x55, 0x79, 0x2f,
+       0x0e, 0x50, 0x3b, 0xef, 0x57, 0x8c, 0xd5, 0xe5,
+       0x01, 0xb5, 0x77, 0x8e, 0xd5, 0x30, 0xad, 0x88,
+       0x9b, 0xc1, 0xb4, 0x1d, 0xb9, 0xd9, 0xfc, 0x33,
+       0xb8, 0x75, 0xce, 0x3d, 0x43, 0x57, 0xda, 0xb5,
+       0x82, 0x54, 0x59, 0x28, 0xbb, 0xd3, 0x6a, 0x8e,
+       0x54, 0x95, 0x33, 0x9d, 0x9e, 0xbf, 0x59, 0xe5,
+       0x1c, 0x1f, 0x30, 0x33, 0xce, 0xfa, 0x80, 0xfd,
+       0x29, 0x75, 0x1c, 0xf8, 0x75, 0xaa, 0x67, 0x37,
+       0x06, 0x3d, 0xbb, 0xb1, 0x7e, 0x83, 0x4f, 0x8b,
+       0x3d, 0xa1, 0xd8, 0xfc, 0xfa, 0x68, 0xac, 0x59,
+       0x86, 0x9f, 0x75, 0x5f, 0x34, 0xf3, 0xd1, 0x46,
+       0xe3, 0xdd, 0x14, 0xc0, 0xdf, 0x7a, 0xad, 0x3e,
+       0xa6, 0x15, 0x39, 0x0f, 0x0d, 0xd6, 0x86, 0xef,
+       0x9c, 0xba, 0x52, 0xcb, 0x75, 0xf4, 0x40, 0x07,
+       0x14, 0x7c, 0x52, 0xf6, 0xd4, 0xca, 0xe1, 0x3e,
+       0x88, 0xa9, 0x92, 0x8d, 0x25, 0x33, 0xf3, 0x80,
+       0x4d, 0xea, 0xce, 0x9b, 0x42, 0x2c, 0x65, 0xc9,
+       0x18, 0xb2, 0xe4, 0x23, 0x98, 0x6c, 0xc1, 0xb8,
+       0x83, 0xf7, 0xcd, 0xcf, 0x6a, 0x24, 0xb8, 0xb2,
+       0x95, 0xbe, 0xb1, 0x86, 0x7d, 0x64, 0x95, 0x52,
+       0x99, 0x26, 0x60, 0x2b, 0x7f, 0x56, 0x28, 0x25,
+       0xfd, 0xce, 0x13, 0x72, 0x63, 0xca, 0x1e, 0x91,
+       0x4b, 0x50, 0x42, 0x6c, 0xba, 0x68, 0xe6, 0x1a,
+       0xf6, 0xb3, 0x14, 0xad, 0xcf, 0x7f, 0x96, 0xc0,
+       0xfb, 0xfc, 0x67, 0x16, 0x4f, 0x88, 0xe9, 0x09,
+       0xb6, 0x8f, 0xb7, 0xeb, 0x68, 0x1f, 0xf6, 0xa5,
+       0x4e, 0x6b, 0x57, 0xcc, 0x16, 0xe9, 0xa0, 0xc7,
+       0xc9, 0xf4, 0xcc, 0x27, 0xed, 0x4d, 0xe5, 0xe5,
+       0x78, 0xa4, 0x2e, 0x15, 0x37, 0x5d, 0x7a, 0xf9,
+       0x77, 0x9d, 0x6b, 0x43, 0x0c, 0xcb, 0x47, 0x5c,
+       0x26, 0xea, 0x30, 0x0c, 0x5c, 0x67, 0x12, 0x16,
+       0x18, 0x4d, 0x32, 0xc3, 0x27, 0x7a, 0x8a, 0x10,
+       0xff, 0x21, 0xc3, 0x9b, 0xd7, 0xad, 0x11, 0x70,
+       0x6c, 0xc5, 0x64, 0xd2, 0xa8, 0xc9, 0x2f, 0x34,
+       0x83, 0xa8, 0xa7, 0x5c, 0x31, 0x74, 0xce, 0x4c,
+       0x29, 0xe3, 0x85, 0x3e, 0xcd, 0xc0, 0x4e, 0xcd,
+       0x5e, 0x32, 0x8e, 0x2f, 0x5d, 0x7c, 0xe4, 0xdb,
+       0xda, 0x18, 0x07, 0x23, 0xb3, 0xe5, 0x46, 0x94,
+       0xb9, 0xb1, 0x9b, 0x85, 0xb8, 0xff, 0x03, 0x47,
+       0x0b, 0x6d, 0x77, 0x63, 0xec, 0x02, 0xb6, 0xed,
+       0x09, 0x05, 0xfe, 0x48, 0x16, 0x94, 0x5a, 0x94,
+       0xae, 0x8d, 0x72, 0x2e, 0xbd, 0xa3, 0x38, 0x22,
+       0x7e, 0xe7, 0x15, 0xd9, 0x0e, 0x5c, 0x03, 0xd5,
+       0x54, 0x40, 0x9c, 0x9e, 0xf8, 0xde, 0xe8, 0x0e,
+       0x75, 0x64, 0x02, 0xd9, 0x2a, 0xe3, 0x6e, 0xe4,
+       0xe3, 0x64, 0xbc, 0xad, 0x9c, 0xe2, 0xbd, 0xb3,
+       0x88, 0x45, 0x0b, 0x26, 0xf6, 0x39, 0x0a, 0xd3,
+       0x40, 0xbc, 0x4a, 0xef, 0x7c, 0x48, 0x97, 0x11,
+       0xb7, 0x29, 0xbf, 0x30, 0x0f, 0x44, 0x63, 0x7e,
+       0xa1, 0x03, 0x12, 0xef, 0x66, 0xf3, 0xf8, 0x58,
+       0x36, 0x5e, 0xea, 0x31, 0xcf, 0xab, 0x01, 0xc0,
+       0x79, 0xaa, 0x4d, 0x49, 0x0b, 0xe8, 0x76, 0x91,
+       0x6d, 0x48, 0x11, 0xe1, 0xbd, 0xcd, 0x01, 0x9b,
+       0x7f, 0xc2, 0x06, 0xbd, 0x42, 0xe7, 0x15, 0xff,
+       0x14, 0x69, 0x3a, 0xe9, 0x0d, 0xae, 0x1b, 0x8b,
+       0xd7, 0x3a, 0x79, 0x1f, 0xbe, 0xb7, 0x82, 0xd7,
+       0xf2, 0x3d, 0x3f, 0x62, 0x7d, 0xbf, 0xf5, 0x84,
+       0x5c, 0xa1, 0x22, 0xf1, 0xe9, 0x9c, 0x42, 0xc1,
+       0xe6, 0x7f, 0x02, 0xbd, 0x3b, 0x8b, 0x79, 0x3f,
+       0xc4, 0x3d, 0x02, 0x98, 0x5e, 0x85, 0xb5, 0x1f,
+       0x50, 0x69, 0x8b, 0xe9, 0xab, 0xaf, 0x21, 0x97,
+       0x04, 0x91, 0x45, 0x22, 0x18, 0xfa, 0x73, 0x0a,
+       0xd7, 0xd8, 0xa4, 0x6e, 0x95, 0x5f, 0x86, 0x4a,
+       0x23, 0xd0, 0x17, 0x62, 0x2f, 0xd7, 0x2a, 0xf0,
+       0x5e, 0x52, 0x8e, 0xaa, 0x2f, 0xef, 0x59, 0xb9,
+       0x86, 0xbc, 0x87, 0xed, 0xfc, 0xe2, 0xc2, 0x6f,
+       0x6b, 0x43, 0x2e, 0x6d, 0xf6, 0x74, 0xb0, 0x5e,
+       0x21, 0x7b, 0x6d, 0x68, 0x19, 0xb2, 0x47, 0x73,
+       0x07, 0xcf, 0x77, 0xe4, 0x04, 0xd2, 0xbf, 0x96,
+       0xaf, 0xda, 0x9f, 0x23, 0x38, 0x9f, 0x7e, 0xb1,
+       0x75, 0x37, 0xae, 0xcf, 0x8e, 0xec, 0x13, 0xf3,
+       0x86, 0xe4, 0xcc, 0x1b, 0x92, 0xb3, 0x45, 0xcd,
+       0x89, 0x73, 0xe6, 0x17, 0x41, 0x35, 0xa7, 0x19,
+       0x2d, 0x25, 0xfa, 0x57, 0x5f, 0x34, 0x90, 0x8d,
+       0x1c, 0x62, 0x0b, 0x71, 0x9c, 0x1e, 0xc1, 0xbe,
+       0xd5, 0xf5, 0xba, 0xfa, 0xaf, 0xa0, 0x37, 0xa9,
+       0x47, 0xab, 0xa3, 0x7b, 0x89, 0x8f, 0xd9, 0x23,
+       0x0b, 0x69, 0xc4, 0x22, 0xf4, 0x31, 0xca, 0xc9,
+       0x72, 0x86, 0x66, 0x79, 0x58, 0x3e, 0xda, 0xd7,
+       0xb4, 0x17, 0x73, 0xad, 0xc6, 0x5c, 0x2f, 0x63,
+       0x98, 0x4a, 0x9d, 0xa8, 0x30, 0x8f, 0x86, 0xe6,
+       0x41, 0x5d, 0x17, 0x7a, 0x76, 0x0d, 0xcc, 0x2a,
+       0xa2, 0x7f, 0xac, 0x3f, 0xc5, 0xc7, 0x1c, 0x7a,
+       0x68, 0x6c, 0xa6, 0x54, 0xf7, 0x1a, 0x62, 0xe9,
+       0xef, 0x5e, 0x43, 0xba, 0x42, 0xe4, 0x1c, 0xcb,
+       0xe6, 0x06, 0xf4, 0x06, 0x91, 0xfa, 0xa5, 0x2f,
+       0xa5, 0x3e, 0xc4, 0xfd, 0x49, 0x7d, 0x31, 0xe3,
+       0x3c, 0x96, 0xcd, 0xa1, 0x76, 0xcc, 0xad, 0xe7,
+       0xd6, 0x40, 0x1f, 0xe0, 0x6d, 0x7f, 0xf7, 0x45,
+       0x29, 0x4b, 0x34, 0x49, 0x38, 0x23, 0xe9, 0x6b,
+       0x35, 0x6f, 0x92, 0xed, 0x24, 0x4c, 0x62, 0xd6,
+       0xc2, 0xe2, 0x1f, 0x75, 0xae, 0xec, 0x37, 0x3e,
+       0xf2, 0x1c, 0xe9, 0xcb, 0xed, 0xcc, 0x53, 0x75,
+       0x26, 0xdc, 0x0f, 0x3a, 0xe6, 0x23, 0xc1, 0xbb,
+       0x22, 0xf3, 0x92, 0xe0, 0xdd, 0x5a, 0x56, 0x8a,
+       0x85, 0xf9, 0x7b, 0xf0, 0xae, 0xb7, 0x4a, 0x57,
+       0x53, 0x6e, 0xe0, 0x5e, 0x53, 0x31, 0xf3, 0x9a,
+       0x8e, 0xaa, 0x5e, 0x53, 0x7e, 0x22, 0xe6, 0xdd,
+       0xc4, 0xf3, 0xa6, 0xed, 0xe2, 0x79, 0x53, 0x86,
+       0xe5, 0x8d, 0xaf, 0xd2, 0xd7, 0x94, 0xa3, 0x07,
+       0x05, 0xef, 0x1a, 0x7d, 0x3a, 0x03, 0xf9, 0x4f,
+       0x7d, 0xe2, 0x6e, 0x6d, 0xee, 0x90, 0xdc, 0xe2,
+       0x0a, 0x29, 0x53, 0xac, 0x93, 0xa6, 0x8a, 0x8f,
+       0x89, 0x0d, 0x92, 0x3a, 0xfb, 0x1f, 0x3e, 0x25,
+       0xc2, 0xc0, 0x5e, 0xa9, 0x46, 0x8d, 0x1d, 0x15,
+       0xe1, 0x9a, 0xea, 0x65, 0x1f, 0xa6, 0xf5, 0x8f,
+       0xa4, 0x24, 0x8a, 0x70, 0x78, 0xb7, 0x8a, 0x79,
+       0x8d, 0x5b, 0x9d, 0xc3, 0x2f, 0x6b, 0x56, 0xe7,
+       0xf0, 0x0b, 0xdc, 0xea, 0x1c, 0xde, 0xf4, 0x91,
+       0xa7, 0xdb, 0xa9, 0xcd, 0xd9, 0x2a, 0x75, 0x88,
+       0xeb, 0xe2, 0xe1, 0x15, 0xa2, 0x6a, 0xe5, 0x0f,
+       0xb7, 0xa8, 0xf9, 0xe5, 0x68, 0xfe, 0x45, 0x6a,
+       0xfe, 0x1a, 0xcd, 0x6f, 0x51, 0x29, 0x8b, 0x99,
+       0x87, 0x08, 0x87, 0x0b, 0x99, 0x8f, 0x08, 0x87,
+       0xf3, 0xa2, 0x39, 0x26, 0xa9, 0x39, 0x52, 0x3d,
+       0xa1, 0xdf, 0x7b, 0x34, 0xed, 0x76, 0xe3, 0x0a,
+       0xf9, 0xb7, 0x62, 0xc2, 0x98, 0x8f, 0xca, 0x48,
+       0xbe, 0xde, 0x0c, 0x9c, 0x79, 0xf4, 0x6e, 0xdd,
+       0xce, 0x5a, 0x25, 0xbe, 0x1b, 0xd7, 0xe9, 0x5d,
+       0x1d, 0x38, 0xbf, 0x9f, 0x13, 0xe1, 0x9d, 0x2b,
+       0xbe, 0x72, 0xaf, 0x4e, 0xd1, 0xfb, 0xca, 0xb5,
+       0x9a, 0xfa, 0x3b, 0x30, 0xdf, 0x62, 0x57, 0x2f,
+       0xc0, 0x94, 0x11, 0x01, 0xc3, 0xeb, 0x23, 0xe4,
+       0x04, 0xaf, 0x6d, 0xfe, 0xbb, 0x91, 0x3e, 0x94,
+       0x67, 0xa3, 0x62, 0xaa, 0x9d, 0x7d, 0xde, 0x53,
+       0xd9, 0x9e, 0xfe, 0xf8, 0x02, 0xe7, 0x12, 0xf4,
+       0x91, 0xde, 0xe9, 0x4a, 0xb8, 0x1b, 0xf9, 0xdf,
+       0x8d, 0x39, 0x92, 0xfc, 0x63, 0x77, 0xfa, 0xc9,
+       0x5f, 0x99, 0xeb, 0x5c, 0x82, 0x6b, 0x8b, 0x77,
+       0x9e, 0x3f, 0x87, 0x74, 0xe8, 0xe9, 0xc0, 0x3b,
+       0xcf, 0xd8, 0xec, 0xec, 0xfc, 0xf1, 0xab, 0x2c,
+       0xb6, 0xba, 0xb2, 0xbd, 0x86, 0xad, 0x08, 0xd9,
+       0xea, 0xdc, 0x94, 0x63, 0xf3, 0xd5, 0x1e, 0x77,
+       0x65, 0x87, 0x6c, 0x68, 0x9b, 0x34, 0x4c, 0x0d,
+       0x62, 0xc6, 0x33, 0xcc, 0x8f, 0xf9, 0xea, 0x1f,
+       0xde, 0xf1, 0x90, 0x7d, 0x52, 0x7a, 0xab, 0xcb,
+       0x35, 0x69, 0xbc, 0x93, 0xaf, 0x5f, 0x19, 0x61,
+       0x6b, 0x5c, 0xd6, 0xdb, 0x70, 0x63, 0x2f, 0xd0,
+       0x39, 0x0b, 0x3c, 0x2e, 0x61, 0x7c, 0xf3, 0x90,
+       0xf4, 0x0c, 0xd9, 0xa1, 0xce, 0xbd, 0x19, 0xbe,
+       0x72, 0xa0, 0xf3, 0xc4, 0x98, 0xce, 0xde, 0x08,
+       0xf2, 0xf1, 0x76, 0xe8, 0x12, 0xd2, 0xdc, 0x2f,
+       0x5b, 0x58, 0x9a, 0x5d, 0xed, 0x2f, 0xf2, 0x09,
+       0x52, 0x31, 0x17, 0xc9, 0x0d, 0x0e, 0x1d, 0xae,
+       0xa1, 0x34, 0x41, 0xcd, 0x57, 0xa8, 0xe6, 0xdb,
+       0xc9, 0xe8, 0x26, 0xc8, 0x7e, 0x96, 0xb3, 0x50,
+       0x2d, 0x2d, 0x55, 0x4e, 0xf6, 0x95, 0xe3, 0x6a,
+       0xd0, 0x88, 0x54, 0xa9, 0xca, 0xd8, 0x8f, 0x3a,
+       0x6d, 0xf7, 0x47, 0x22, 0x73, 0xde, 0x8d, 0x5c,
+       0x15, 0xe1, 0x50, 0x88, 0x9e, 0x18, 0xd0, 0x7e,
+       0xa8, 0x9e, 0x4c, 0xb2, 0xbb, 0x9f, 0xec, 0x48,
+       0x60, 0x73, 0x23, 0x7b, 0xdb, 0x50, 0xa7, 0xd0,
+       0x53, 0x03, 0x3d, 0xf2, 0x5d, 0xe8, 0x71, 0x4a,
+       0x76, 0x8f, 0x53, 0x4c, 0x64, 0x5f, 0x0b, 0x88,
+       0xd4, 0xc1, 0x21, 0x4f, 0x17, 0xdb, 0x51, 0x85,
+       0xa1, 0xe9, 0x22, 0xdc, 0x38, 0xc4, 0xed, 0xc7,
+       0xa1, 0x1c, 0xb7, 0x9e, 0xd5, 0xd3, 0xe8, 0x2b,
+       0xaf, 0x3a, 0x30, 0x43, 0xaf, 0xf1, 0xfe, 0x84,
+       0xcd, 0x17, 0x9f, 0x54, 0xe4, 0x8d, 0xa3, 0x11,
+       0x23, 0x83, 0xce, 0xed, 0xd5, 0x2b, 0xfa, 0xe2,
+       0x10, 0x5a, 0x6c, 0x36, 0x26, 0xe0, 0x30, 0x7d,
+       0x43, 0xe7, 0x8b, 0xe5, 0xc2, 0x38, 0x5a, 0x8f,
+       0x17, 0xaf, 0x61, 0xad, 0x49, 0xc2, 0x16, 0x64,
+       0x50, 0x0b, 0x76, 0xaa, 0x25, 0xbd, 0x8d, 0x6b,
+       0xe6, 0x1b, 0x8b, 0xc8, 0x87, 0xc4, 0x71, 0x06,
+       0x6f, 0x1f, 0xc2, 0x74, 0x87, 0x96, 0x4e, 0x75,
+       0x7a, 0x7b, 0x17, 0xed, 0x79, 0x23, 0xed, 0x55,
+       0xe2, 0x49, 0xba, 0x8c, 0x6a, 0x2b, 0x7a, 0x57,
+       0xa3, 0xd4, 0x15, 0x0f, 0xbc, 0xbd, 0x91, 0x8f,
+       0xe6, 0xb7, 0xd7, 0x7b, 0xd6, 0xf4, 0x2c, 0x08,
+       0xb9, 0xf8, 0xfc, 0xf5, 0x76, 0x07, 0xbb, 0x87,
+       0x10, 0xcf, 0xef, 0x1d, 0x60, 0xbc, 0x59, 0x5d,
+       0x29, 0x4f, 0x92, 0x53, 0x7d, 0xe5, 0x81, 0x9f,
+       0x1f, 0xbf, 0x5b, 0x49, 0x0e, 0x75, 0xe8, 0xa1,
+       0x5a, 0xa7, 0x24, 0x58, 0x9c, 0x26, 0x98, 0xab,
+       0x53, 0x2c, 0x16, 0xa7, 0x1e, 0x16, 0x60, 0x3f,
+       0xbc, 0xed, 0xe4, 0x92, 0x7f, 0xbb, 0x40, 0x84,
+       0x2f, 0xc2, 0x7c, 0x1c, 0xbc, 0x9d, 0xc9, 0xe7,
+       0xa1, 0xb7, 0xd3, 0x58, 0x5a, 0x3a, 0xd6, 0x73,
+       0x2a, 0xd5, 0x73, 0xf8, 0x9d, 0x07, 0x6c, 0xef,
+       0x86, 0x54, 0xf0, 0xec, 0xdf, 0x19, 0x92, 0xe1,
+       0x60, 0x7f, 0x65, 0x3b, 0x52, 0x3d, 0x7c, 0x2b,
+       0x55, 0x02, 0x78, 0xd6, 0x78, 0xf6, 0x77, 0xad,
+       0x91, 0x2d, 0xbc, 0xdd, 0x0a, 0x44, 0x52, 0xd4,
+       0xb5, 0x13, 0x96, 0x7a, 0xf0, 0x00, 0xd6, 0x32,
+       0x4b, 0x49, 0xc4, 0xbc, 0xcc, 0x4a, 0x62, 0x2f,
+       0xc1, 0x17, 0x53, 0xb1, 0x9f, 0xe0, 0x8b, 0x3c,
+       0x36, 0x1b, 0x3e, 0x81, 0x34, 0x2f, 0x62, 0x6a,
+       0x01, 0xb3, 0x7a, 0xaa, 0x1c, 0x0f, 0x3e, 0x83,
+       0xe9, 0x89, 0x7f, 0xe6, 0x94, 0x93, 0x6d, 0x9f,
+       0x3d, 0x4b, 0xda, 0x3f, 0x23, 0xe8, 0x1f, 0xc5,
+       0xbf, 0x1c, 0xc1, 0xde, 0x66, 0x7f, 0x93, 0x5d,
+       0x8f, 0xb1, 0xeb, 0x71, 0x76, 0x3d, 0xc0, 0xae,
+       0x87, 0xd8, 0xf5, 0x08, 0x7f, 0xe3, 0x9d, 0xbf,
+       0x47, 0x3b, 0x63, 0x57, 0x6a, 0x18, 0x5b, 0xb5,
+       0x7d, 0xe4, 0x1e, 0xd8, 0x1e, 0x4f, 0x7a, 0x1a,
+       0xc2, 0x5f, 0x0f, 0x86, 0x7b, 0x61, 0xfb, 0xa8,
+       0x5a, 0xd8, 0x6e, 0xc3, 0xbe, 0xb5, 0x6d, 0x10,
+       0xa3, 0xcf, 0xfa, 0x1c, 0xf7, 0x3d, 0xb6, 0x08,
+       0x1c, 0xdf, 0x78, 0xa2, 0x31, 0x10, 0x5c, 0xd5,
+       0xde, 0xd4, 0xea, 0xef, 0x99, 0x00, 0x98, 0x26,
+       0xb5, 0x35, 0xc8, 0xca, 0xe2, 0x25, 0x4b, 0x9b,
+       0x2f, 0x9e, 0x4d, 0x03, 0x24, 0x2c, 0x5c, 0xb9,
+       0xa2, 0x7e, 0x79, 0x5d, 0xcb, 0xb2, 0xcc, 0xac,
+       0xc9, 0x90, 0x85, 0xb9, 0x84, 0x68, 0x9d, 0x27,
+       0xdf, 0xd4, 0x86, 0x47, 0x1e, 0x9d, 0x32, 0xe9,
+       0xfe, 0x68, 0x4c, 0xbc, 0x3f, 0x75, 0xd2, 0x27,
+       0xf7, 0xa6, 0x4f, 0xc9, 0x98, 0x38, 0x6d, 0xc6,
+       0x63, 0x1d, 0xe0, 0x98, 0x33, 0xbf, 0xc4, 0x57,
+       0xb3, 0x70, 0x6e, 0xd9, 0xec, 0xaa, 0x81, 0xf1,
+       0x54, 0x8e, 0xab, 0xba, 0xb8, 0x74, 0xa6, 0xc7,
+       0x5b, 0x5e, 0x71, 0xfd, 0xfc, 0x3f, 0x51, 0x39,
+       0xd3, 0x17, 0xd4, 0x16, 0xcd, 0x73, 0x57, 0xce,
+       0x7a, 0x78, 0xea, 0xe3, 0x7f, 0xa6, 0x9c, 0x6f,
+       0xfe, 0xcd, 0x4d, 0xe5, 0x4c, 0xf8, 0x2f, 0x29,
+       0x67, 0x50, 0x6e, 0x93, 0xa7, 0x69, 0x72, 0x5b,
+       0x49, 0x72, 0x7b, 0xe4, 0xd1, 0x61, 0x72, 0x7b,
+       0xf8, 0x3e, 0x2e, 0xb7, 0x55, 0x9a, 0xdc, 0xa6,
+       0xfc, 0x65, 0x72, 0x1b, 0x3f, 0x7e, 0x42, 0xda,
+       0xbd, 0x8f, 0xa5, 0x4f, 0xca, 0x98, 0xf8, 0xf8,
+       0xfd, 0x5a, 0x7b, 0x16, 0x50, 0x7b, 0xbe, 0xf9,
+       0x37, 0xc3, 0xda, 0x33, 0x35, 0x95, 0xb7, 0x67,
+       0x21, 0x6f, 0x4f, 0xe1, 0xf4, 0x19, 0x7f, 0x59,
+       0x7b, 0xfe, 0xab, 0xca, 0x19, 0x94, 0xdb, 0x99,
+       0x5d, 0xc3, 0xf4, 0x6d, 0xe0, 0xfe, 0x61, 0x72,
+       0xbb, 0x7e, 0x7e, 0xc2, 0x7f, 0x44, 0xdf, 0x56,
+       0x8f, 0x4f, 0xfd, 0xe7, 0x34, 0x55, 0x0f, 0xc4,
+       0x61, 0x7a, 0x70, 0x7a, 0xd2, 0xb0, 0xf6, 0x7c,
+       0x70, 0xf0, 0xb1, 0xff, 0x90, 0x1e, 0xbc, 0xe1,
+       0xfc, 0x61, 0xd7, 0xbe, 0xff, 0xfd, 0xe6, 0x8f,
+       0x7f, 0xf0, 0x13, 0xa6, 0x07, 0x1f, 0x77, 0x7d,
+       0xff, 0xb5, 0x1b, 0x2f, 0xfd, 0x68, 0x5b, 0xdf,
+       0x6e, 0xae, 0x07, 0x17, 0xce, 0xf0, 0x5d, 0x22,
+       0xff, 0xf4, 0xf0, 0x7d, 0xbc, 0x3d, 0xaf, 0xff,
+       0xea, 0x93, 0x57, 0xf6, 0xfe, 0xaf, 0x3d, 0x7f,
+       0xb1, 0x1e, 0xa4, 0x5f, 0x4c, 0xbd, 0x2f, 0xe3,
+       0x9f, 0x7b, 0xc6, 0x7f, 0x72, 0x76, 0xe2, 0x64,
+       0x2c, 0x47, 0x5a, 0xa5, 0xe9, 0xdb, 0x63, 0x69,
+       0x54, 0xce, 0x37, 0x34, 0xb9, 0x2d, 0x6b, 0x6f,
+       0x67, 0xe5, 0x3c, 0xc1, 0xe4, 0x96, 0xf9, 0xf0,
+       0xd4, 0x69, 0x7f, 0x59, 0x39, 0x83, 0xfd, 0xd3,
+       0xf5, 0x38, 0xca, 0xcd, 0xb5, 0x50, 0xd3, 0x03,
+       0x60, 0x72, 0x9b, 0xa3, 0xc9, 0x6d, 0xd6, 0xbd,
+       0x5c, 0x0f, 0xe6, 0x33, 0xb9, 0xcd, 0xc8, 0x9a,
+       0x72, 0xff, 0x5f, 0xaa, 0x07, 0x13, 0xfe, 0x2b,
+       0xca, 0x71, 0xb9, 0x8b, 0x8a, 0x4b, 0x90, 0x53,
+       0x19, 0xb1, 0xaa, 0x9c, 0x5d, 0x35, 0xc7, 0x57,
+       0x5d, 0x33, 0x77, 0xde, 0xfc, 0xda, 0x05, 0x0b,
+       0xf9, 0xde, 0x06, 0x65, 0x71, 0x13, 0x09, 0xad,
+       0xa5, 0xd5, 0xff, 0x8d, 0x40, 0x5b, 0xb0, 0x7d,
+       0xf9, 0x13, 0x2b, 0x56, 0xae, 0x12, 0x06, 0x37,
+       0x40, 0x0c, 0xb1, 0x5a, 0xf7, 0x8d, 0x4f, 0x9b,
+       0x30, 0x19, 0xe5, 0xf9, 0xc8, 0xa3, 0x85, 0xd3,
+       0x9d, 0x59, 0x17, 0xcf, 0xf6, 0x5c, 0x3f, 0x3f,
+       0xb0, 0xa8, 0xe3, 0x9f, 0xbb, 0x1e, 0x7f, 0x63,
+       0xe7, 0x37, 0xff, 0x46, 0xd8, 0xf9, 0x67, 0xfe,
+       0x84, 0xf1, 0xa9, 0xff, 0x84, 0xfa, 0x78, 0x5f,
+       0xc6, 0xc4, 0x49, 0xf7, 0x67, 0x4e, 0xce, 0x9a,
+       0x32, 0x58, 0xc4, 0xd4, 0x87, 0x0b, 0xa7, 0x4d,
+       0x9f, 0xe1, 0xfc, 0xf2, 0x8a, 0x3e, 0xb2, 0xe8,
+       0xd1, 0xc7, 0x1e, 0xdf, 0xf9, 0xe5, 0xd5, 0xfd,
+       0x66, 0xc7, 0xdf, 0xec, 0xfc, 0x64, 0xe0, 0xe2,
+       0xce, 0xf3, 0x67, 0x77, 0x7e, 0xb2, 0x73, 0x67,
+       0xcf, 0xce, 0xff, 0xc7, 0xff, 0x06, 0x25, 0xcb,
+       0x45, 0xfa, 0x1f, 0xfd, 0x76, 0xc7, 0xff, 0xfd,
+       0x7f, 0xec, 0xbc, 0xaa, 0xe8, 0xc9, 0x21, 0xee,
+       0x40, 0xa3, 0xb4, 0x54, 0xa8, 0x6a, 0x6d, 0x6a,
+       0x09, 0x0a, 0x18, 0xac, 0x5f, 0xdc, 0xd8, 0x20,
+       0x48, 0xc1, 0xe8, 0x09, 0xac, 0x69, 0xe0, 0xad,
+       0xf6, 0x09, 0x7f, 0x96, 0x68, 0x28, 0x41, 0x5b,
+       0x63, 0xf0, 0xab, 0x39, 0xdc, 0x42, 0x30, 0x9c,
+       0x3d, 0xed, 0x85, 0xfa, 0x0a, 0xf6, 0x98, 0x70,
+       0x2b, 0x4b, 0x86, 0x74, 0x35, 0x37, 0x0f, 0x45,
+       0xb6, 0x09, 0xf5, 0xcd, 0x8d, 0x52, 0x80, 0xce,
+       0x63, 0x59, 0x86, 0x4c, 0x03, 0x2b, 0x87, 0x1c,
+       0x2b, 0xab, 0xb2, 0xcc, 0xca, 0xca, 0xb2, 0x80,
+       0x8b, 0x9f, 0xcc, 0xd2, 0x10, 0xa0, 0x6b, 0x53,
+       0x9b, 0xd0, 0xd2, 0xfa, 0x04, 0x9d, 0x20, 0x5b,
+       0xd9, 0x2a, 0x34, 0x34, 0xb5, 0x2d, 0x15, 0x9a,
+       0x5a, 0xd4, 0x24, 0x46, 0x5c, 0x13, 0x90, 0xea,
+       0x97, 0x0a, 0xf5, 0xad, 0x81, 0x40, 0xbb, 0x3f,
+       0x88, 0xd5, 0x64, 0x48, 0xb7, 0xd4, 0x20, 0xb8,
+       0x9b, 0x5b, 0xeb, 0x97, 0x3e, 0x5e, 0xb4, 0xb8,
+       0xb1, 0x7e, 0x69, 0x5b, 0xfb, 0x32, 0x8e, 0xaf,
+       0xa4, 0x73, 0x5f, 0x84, 0xe2, 0xd9, 0xd5, 0x9c,
+       0x13, 0xc3, 0x15, 0x33, 0x9e, 0x6d, 0xec, 0xc0,
+       0xb0, 0xc6, 0xc9, 0xfe, 0x40, 0x6b, 0xb0, 0xb1,
+       0x3e, 0xca, 0xa8, 0xac, 0x85, 0x76, 0xbc, 0x23,
+       0xb3, 0xa6, 0xe0, 0x32, 0xc9, 0xaf, 0x65, 0x08,
+       0x20, 0x05, 0x55, 0x9f, 0x8e, 0x87, 0x69, 0x5c,
+       0xe6, 0x0f, 0xae, 0x54, 0x89, 0x8b, 0x4b, 0x38,
+       0x5f, 0x76, 0xda, 0xcc, 0x90, 0x12, 0x5b, 0x84,
+       0xd2, 0xd2, 0x6a, 0x3a, 0x69, 0xa6, 0xac, 0x25,
+       0x98, 0xc5, 0xc2, 0xd1, 0xe2, 0x33, 0x66, 0x63,
+       0x8c, 0x0e, 0x33, 0x2b, 0x2e, 0x9a, 0x4c, 0x09,
+       0xc4, 0xb2, 0xad, 0xdd, 0xef, 0x6f, 0x0d, 0x60,
+       0x1d, 0x26, 0x22, 0x4f, 0xf6, 0xce, 0x42, 0xb3,
+       0xe0, 0x97, 0x82, 0x8b, 0xd5, 0xe2, 0x1b, 0x97,
+       0x37, 0xd5, 0x0f, 0x3d, 0x9a, 0x86, 0x61, 0x99,
+       0x0e, 0x49, 0xcd, 0x28, 0xc3, 0x86, 0x95, 0x42,
+       0xe3, 0x8a, 0xa6, 0x36, 0x94, 0xf6, 0x60, 0xf3,
+       0xe4, 0x76, 0xec, 0x89, 0x41, 0xba, 0x9b, 0xf2,
+       0x16, 0x49, 0x2d, 0xf7, 0x05, 0x85, 0x7a, 0xcc,
+       0x1b, 0x6c, 0x14, 0xd8, 0xb9, 0x36, 0x0c, 0x3d,
+       0xb7, 0x65, 0x29, 0x4a, 0xbe, 0x45, 0x3b, 0x6e,
+       0x8d, 0x37, 0x51, 0xad, 0x4e, 0xdb, 0xca, 0x96,
+       0xa0, 0xb4, 0x62, 0x18, 0x4a, 0xed, 0xcb, 0x61,
+       0xb8, 0x40, 0xa3, 0x82, 0x35, 0x69, 0x0c, 0x0c,
+       0x43, 0xa2, 0x44, 0xdb, 0x1b, 0x87, 0x61, 0x5a,
+       0xa4, 0x65, 0xc3, 0x11, 0x6d, 0xc1, 0x40, 0x53,
+       0x8b, 0x32, 0x0c, 0xd5, 0xb8, 0x82, 0x36, 0xba,
+       0xd2, 0xd9, 0x3c, 0xb7, 0x69, 0x07, 0xd7, 0x84,
+       0xd6, 0x56, 0x01, 0x2b, 0xba, 0x52, 0xa8, 0x63,
+       0x2a, 0xe7, 0x67, 0x2a, 0xc7, 0x52, 0x5a, 0x65,
+       0xb9, 0xb5, 0x45, 0x98, 0x1f, 0x68, 0x6d, 0x51,
+       0xa2, 0x55, 0x12, 0x5a, 0xda, 0x97, 0xd5, 0xa9,
+       0x35, 0x9b, 0xfc, 0xe7, 0xfe, 0x04, 0x4f, 0x49,
+       0x45, 0x95, 0x50, 0xe5, 0x9a, 0x59, 0x22, 0xfc,
+       0x59, 0xda, 0xc9, 0x16, 0x1f, 0x9d, 0xc1, 0x83,
+       0xe5, 0x08, 0x2d, 0x8d, 0x4f, 0x4c, 0xc6, 0xd6,
+       0x0a, 0x74, 0x00, 0x72, 0xdb, 0x62, 0xd4, 0x62,
+       0x54, 0x81, 0x65, 0xad, 0x0d, 0x4d, 0xf2, 0xca,
+       0x68, 0x35, 0xda, 0x2c, 0x2e, 0xa2, 0xd6, 0x06,
+       0x42, 0x53, 0x0b, 0x36, 0x1d, 0xa9, 0xa5, 0xb6,
+       0xb6, 0xc6, 0x65, 0x75, 0xd8, 0xc4, 0xfc, 0x02,
+       0xc7, 0x0a, 0x07, 0x76, 0x41, 0x43, 0xa3, 0xa5,
+       0x78, 0x28, 0x21, 0xff, 0x9b, 0x4a, 0x8a, 0x14,
+       0xa5, 0x9d, 0x72, 0xdb, 0x6c, 0x9e, 0xdb, 0x65,
+       0x5b, 0xdc, 0xb8, 0x42, 0x68, 0x68, 0x5f, 0xe6,
+       0x17, 0x5a, 0x65, 0x41, 0x1d, 0x8b, 0x83, 0x75,
+       0xe3, 0x08, 0xcb, 0xac, 0x7f, 0x6f, 0xc6, 0xca,
+       0xdb, 0x65, 0x94, 0xda, 0xea, 0xcb, 0xca, 0x6e,
+       0xca, 0x6a, 0x29, 0xa1, 0x34, 0xec, 0x1d, 0x32,
+       0x40, 0x51, 0x4a, 0x26, 0xa9, 0x29, 0x42, 0x63,
+       0x43, 0x13, 0x2a, 0x65, 0x7b, 0x5b, 0xb0, 0x75,
+       0xd9, 0x10, 0x69, 0xd5, 0x2c, 0xa8, 0x2a, 0x61,
+       0xbc, 0xb3, 0x84, 0xc1, 0x1c, 0xc1, 0x95, 0xfe,
+       0x46, 0x8d, 0x65, 0x11, 0xa1, 0xda, 0x02, 0xf5,
+       0x42, 0x23, 0xaa, 0x77, 0x43, 0x63, 0x5b, 0x90,
+       0x08, 0xea, 0x5b, 0xfd, 0x68, 0x6c, 0xb4, 0x0a,
+       0xd7, 0x91, 0x65, 0xb0, 0xcc, 0x61, 0x84, 0xc1,
+       0x40, 0x70, 0x90, 0x92, 0x08, 0x97, 0xf9, 0xd1,
+       0x42, 0x09, 0xc1, 0x27, 0x5a, 0x87, 0x51, 0xb7,
+       0x59, 0x66, 0x0f, 0x23, 0x67, 0xbd, 0x3a, 0x95,
+       0x06, 0x4b, 0x73, 0xb4, 0xe0, 0x92, 0xdb, 0x14,
+       0xdc, 0xb8, 0xa2, 0x7e, 0xb1, 0xd4, 0xa2, 0xdc,
+       0x8e, 0x61, 0xe9, 0xed, 0x19, 0xb6, 0x34, 0x58,
+       0xd0, 0x0c, 0x0c, 0x49, 0x21, 0x85, 0x50, 0x53,
+       0xd4, 0x71, 0x21, 0x64, 0x90, 0xe2, 0xd7, 0x4b,
+       0x6d, 0x8d, 0x6d, 0x8d, 0x2d, 0x6d, 0x4d, 0x64,
+       0x2c, 0x27, 0x5a, 0x4a, 0xcb, 0xbe, 0x2c, 0x13,
+       0xd3, 0xa9, 0x76, 0x76, 0x1e, 0x96, 0xa5, 0x68,
+       0x76, 0xd5, 0x10, 0x2a, 0x55, 0x7c, 0x8c, 0x0a,
+       0x45, 0xe4, 0x6f, 0x0c, 0x4c, 0x6e, 0x46, 0x39,
+       0x5b, 0xaa, 0x08, 0xef, 0x6f, 0xaa, 0x6f, 0x69,
+       0x1d, 0x22, 0x64, 0x45, 0x5e, 0x31, 0x39, 0xd0,
+       0x44, 0x44, 0x42, 0x06, 0x4b, 0x9b, 0xe6, 0xc8,
+       0xcc, 0xce, 0xcc, 0xc9, 0xcc, 0xca, 0x9a, 0x28,
+       0x64, 0xc8, 0xd1, 0xe3, 0x19, 0xb1, 0x84, 0x89,
+       0x16, 0x8b, 0xfb, 0x16, 0x0d, 0xa0, 0x8e, 0x6d,
+       0x0c, 0x4e, 0xe1, 0xb3, 0x09, 0x99, 0xc4, 0x26,
+       0x75, 0x60, 0xb3, 0xd1, 0xca, 0x06, 0xab, 0xc5,
+       0xed, 0xfd, 0x33, 0xb9, 0x04, 0x9a, 0x66, 0x86,
+       0x66, 0x28, 0x16, 0x6e, 0xfe, 0xc3, 0x21, 0xd1,
+       0xd8, 0xdc, 0x18, 0x24, 0x63, 0x38, 0x94, 0x77,
+       0x9b, 0x65, 0xd6, 0xfc, 0xac, 0x8c, 0xba, 0x8e,
+       0x27, 0x3a, 0x9a, 0x27, 0x0e, 0x99, 0x76, 0x86,
+       0x30, 0x57, 0x7b, 0xe7, 0x09, 0x29, 0x58, 0xbf,
+       0x18, 0x89, 0x6f, 0xc3, 0x78, 0x79, 0x53, 0xe3,
+       0x13, 0x8c, 0xed, 0x4d, 0xa4, 0xc5, 0x5f, 0x59,
+       0x87, 0x61, 0xc4, 0x33, 0x6f, 0x27, 0x17, 0xda,
+       0xa4, 0x2f, 0x61, 0x97, 0xe0, 0xdc, 0xa3, 0x04,
+       0xa4, 0x65, 0x43, 0x66, 0x5a, 0x4b, 0x0d, 0x12,
+       0xb4, 0xd4, 0xa1, 0xea, 0xfb, 0x87, 0xd0, 0x07,
+       0x71, 0xca, 0x6b, 0x1c, 0xda, 0xad, 0x19, 0x6d,
+       0x13, 0x2d, 0x35, 0xae, 0xdb, 0x70, 0xe6, 0x94,
+       0x41, 0xd2, 0xd2, 0xfb, 0xd4, 0xc4, 0xfb, 0x68,
+       0xae, 0x53, 0x5d, 0x06, 0x4b, 0x71, 0x89, 0x7b,
+       0xee, 0xcc, 0x9b, 0xeb, 0xee, 0xa7, 0x9a, 0x92,
+       0xe6, 0x36, 0xfa, 0xd9, 0x19, 0x6a, 0xcb, 0xd9,
+       0x6c, 0xd7, 0x66, 0xb1, 0x14, 0xfb, 0xca, 0xe6,
+       0x95, 0x08, 0x43, 0x94, 0x82, 0x77, 0x4f, 0x33,
+       0xa6, 0xab, 0x33, 0x72, 0x86, 0x63, 0x4a, 0xf6,
+       0x44, 0x34, 0xc9, 0x01, 0xfa, 0x2d, 0xa3, 0x76,
+       0xa0, 0x66, 0xd1, 0x9c, 0x34, 0x85, 0xcd, 0xae,
+       0x48, 0x4c, 0xac, 0x2c, 0xb3, 0x66, 0xd7, 0xcc,
+       0xf6, 0xdd, 0x5c, 0x6c, 0xb0, 0x3d, 0xa0, 0x4d,
+       0xec, 0xcb, 0x5a, 0x83, 0x74, 0x2c, 0x5b, 0x8b,
+       0x85, 0x4e, 0xf7, 0x74, 0xd5, 0xb0, 0xf9, 0x61,
+       0x90, 0x50, 0x63, 0x2d, 0xc8, 0xcd, 0xa8, 0xb3,
+       0x2b, 0xd9, 0x5c, 0xaa, 0x52, 0xce, 0x19, 0x4a,
+       0x3a, 0x55, 0xf8, 0x46, 0x7b, 0x13, 0xfa, 0x06,
+       0xb7, 0xa5, 0x2f, 0x2e, 0xab, 0x2e, 0x2f, 0xf2,
+       0x94, 0x0f, 0xaf, 0x42, 0x3d, 0x39, 0x0b, 0xb7,
+       0x10, 0xfa, 0xf8, 0xe4, 0x3b, 0xac, 0x7b, 0x35,
+       0x17, 0xc0, 0x52, 0x84, 0x9d, 0x7f, 0x4b, 0xb2,
+       0x3a, 0xe6, 0xeb, 0xdb, 0x03, 0x81, 0x46, 0xf4,
+       0x85, 0xa2, 0xd4, 0x82, 0x90, 0x71, 0xdf, 0x94,
+       0xfb, 0x98, 0x7c, 0xc8, 0xca, 0xb4, 0x04, 0x27,
+       0x5a, 0x2a, 0xa8, 0x83, 0xa9, 0xce, 0xd4, 0x3d,
+       0x5a, 0x7e, 0x76, 0x12, 0x9d, 0xc4, 0xa7, 0x62,
+       0xf4, 0x76, 0x54, 0x03, 0x53, 0xad, 0x91, 0x0e,
+       0x8e, 0x5f, 0x14, 0xbf, 0x34, 0xa8, 0xba, 0xc1,
+       0x56, 0x35, 0x93, 0xa5, 0xba, 0x4a, 0x18, 0x26,
+       0x34, 0x21, 0x4a, 0x1a, 0x5c, 0xdc, 0x48, 0x27,
+       0xdf, 0xb5, 0x93, 0x4b, 0xa1, 0x9e, 0xd1, 0x2f,
+       0x07, 0xd0, 0xc2, 0x12, 0x7e, 0x70, 0x84, 0x5b,
+       0x66, 0xb9, 0xca, 0x4b, 0xa8, 0xe5, 0xc3, 0xc4,
+       0xa9, 0x7a, 0x08, 0x12, 0xcd, 0x6b, 0x43, 0x44,
+       0x50, 0x5c, 0x52, 0x71, 0x6b, 0x61, 0xda, 0x00,
+       0xe0, 0x8d, 0xc0, 0x06, 0xe3, 0x88, 0xe7, 0xae,
+       0xd2, 0x10, 0xd9, 0xcd, 0xae, 0x5a, 0xc0, 0x2c,
+       0x26, 0xb7, 0x96, 0x6a, 0x21, 0xdc, 0x54, 0xb3,
+       0x66, 0xf8, 0xaa, 0xb9, 0x4e, 0xf3, 0x16, 0xb7,
+       0xd4, 0xa9, 0xa3, 0x05, 0x85, 0xc3, 0x15, 0x89,
+       0x57, 0x7d, 0x68, 0x6f, 0xcd, 0xbf, 0x5d, 0x8e,
+       0xa1, 0xba, 0x47, 0x42, 0x1a, 0xd6, 0xbd, 0x39,
+       0xa5, 0xb7, 0x56, 0x9e, 0x15, 0x31, 0x4c, 0x0d,
+       0x98, 0x22, 0x33, 0x01, 0xe2, 0xa4, 0x24, 0xb5,
+       0x69, 0x15, 0x2c, 0xcd, 0x29, 0xfe, 0xf2, 0xdc,
+       0xcc, 0x23, 0xc3, 0x6c, 0xbc, 0xf8, 0x68, 0xbe,
+       0x21, 0x85, 0xbb, 0xdd, 0xc2, 0x90, 0x7e, 0xd7,
+       0x04, 0x20, 0x35, 0xd7, 0xb7, 0x37, 0x93, 0xa0,
+       0xeb, 0x5a, 0x5b, 0x83, 0x93, 0xd9, 0x6c, 0xc1,
+       0x35, 0x13, 0xdd, 0x58, 0x0b, 0xf9, 0x98, 0xb7,
+       0x58, 0x1b, 0x05, 0xa7, 0xcf, 0xa6, 0x16, 0xae,
+       0xe7, 0xec, 0xd4, 0x43, 0x12, 0x0b, 0xf3, 0x46,
+       0x69, 0x38, 0xb5, 0x59, 0xaa, 0x5c, 0xbe, 0x9a,
+       0x5b, 0x32, 0x91, 0xa5, 0x67, 0x06, 0x0a, 0x55,
+       0x31, 0xd8, 0x44, 0xf9, 0xda, 0x2c, 0x15, 0xae,
+       0x9b, 0x9b, 0x13, 0xd5, 0xc6, 0xe6, 0x66, 0x4b,
+       0xf5, 0xed, 0x52, 0x99, 0x50, 0x78, 0x6a, 0xd1,
+       0x97, 0xe8, 0x1c, 0x15, 0x52, 0x1f, 0x68, 0x6f,
+       0x61, 0x26, 0xa7, 0xa8, 0xa2, 0xc4, 0x75, 0xcb,
+       0xd8, 0x67, 0xeb, 0x82, 0xa1, 0xd6, 0x92, 0xdb,
+       0x0d, 0x12, 0x80, 0x90, 0xa1, 0x1e, 0xdf, 0xdb,
+       0xdc, 0xda, 0x86, 0xe3, 0xc5, 0x57, 0xe2, 0x9e,
+       0x3d, 0xbb, 0xe6, 0xa6, 0xec, 0x2a, 0x25, 0x65,
+       0x5a, 0xda, 0xd8, 0xe8, 0xd7, 0x0e, 0xfc, 0x45,
+       0x73, 0xd7, 0xd4, 0x80, 0xa3, 0xcc, 0x62, 0xa9,
+       0xa9, 0x1e, 0x1c, 0x34, 0xcd, 0x24, 0x12, 0xd5,
+       0x38, 0x36, 0xb5, 0x34, 0x92, 0xaa, 0xa0, 0x00,
+       0x90, 0xa4, 0xf8, 0x66, 0x1a, 0xd2, 0x62, 0xe4,
+       0x76, 0x13, 0x1d, 0xce, 0xdb, 0x2a, 0x8b, 0x61,
+       0x76, 0x96, 0x91, 0xb0, 0x99, 0x14, 0x67, 0x67,
+       0xec, 0x88, 0x66, 0x56, 0x1d, 0x62, 0x80, 0xd3,
+       0x61, 0x49, 0x6d, 0x51, 0x49, 0xd5, 0xcd, 0x8d,
+       0x66, 0x7e, 0xce, 0xad, 0x66, 0x76, 0xf6, 0xdc,
+       0x9a, 0xaa, 0xb9, 0x35, 0xc3, 0xf4, 0x42, 0x1d,
+       0x15, 0xad, 0xed, 0x41, 0x7f, 0x7b, 0x90, 0x34,
+       0x58, 0xb5, 0x08, 0xae, 0x52, 0x55, 0x7f, 0xb8,
+       0xdb, 0xa8, 0x39, 0x5a, 0x9a, 0x0f, 0xf8, 0x40,
+       0x41, 0x76, 0xbe, 0xa5, 0xb8, 0xf4, 0x36, 0xf3,
+       0xc2, 0x50, 0xaf, 0x91, 0x93, 0x95, 0x96, 0x95,
+       0xde, 0xe4, 0x3d, 0x0c, 0x73, 0x1f, 0xb2, 0x54,
+       0xb2, 0x2a, 0x57, 0xc5, 0xad, 0xea, 0x47, 0xde,
+       0x1b, 0x25, 0x20, 0x57, 0x7f, 0xb3, 0x84, 0xfe,
+       0x5f, 0x4d, 0x75, 0xd1, 0x6d, 0x89, 0x58, 0x82,
+       0x46, 0x95, 0x9b, 0x5d, 0x7e, 0x7b, 0x56, 0x98,
+       0xb0, 0x78, 0x95, 0x46, 0x26, 0x64, 0x54, 0x05,
+       0x5a, 0x1b, 0x68, 0x9a, 0x5b, 0xde, 0x14, 0x5c,
+       0x99, 0x29, 0x94, 0xb4, 0x07, 0x5a, 0x1f, 0x24,
+       0xa7, 0x23, 0x0b, 0x6d, 0x67, 0xc9, 0x6d, 0x66,
+       0xde, 0xb6, 0x27, 0x9a, 0x68, 0xfa, 0xf2, 0xb7,
+       0x3e, 0xd1, 0x48, 0x27, 0x76, 0x36, 0x58, 0xaa,
+       0x4b, 0x6a, 0x66, 0xb9, 0xaa, 0x70, 0x65, 0xe0,
+       0x8f, 0x6a, 0xe7, 0x54, 0xa1, 0x1a, 0xe7, 0x7d,
+       0x26, 0xff, 0xa5, 0x8d, 0x2b, 0x69, 0x61, 0x97,
+       0x31, 0xb7, 0xda, 0x95, 0x59, 0xe4, 0xc9, 0x2c,
+       0xce, 0x2c, 0x9d, 0x68, 0x99, 0x81, 0x24, 0x83,
+       0xcb, 0x0d, 0x35, 0x47, 0x23, 0x2d, 0x5b, 0x98,
+       0xf9, 0x6b, 0x19, 0x92, 0x68, 0x99, 0x57, 0xe2,
+       0xbb, 0x4d, 0x1d, 0x88, 0xb3, 0x76, 0xea, 0xb4,
+       0x7a, 0xa0, 0x68, 0xad, 0x70, 0x1b, 0x8f, 0x02,
+       0x17, 0x6a, 0x41, 0x4b, 0x79, 0x59, 0x45, 0xc5,
+       0x2d, 0x29, 0xaa, 0x53, 0xc2, 0x99, 0x58, 0x3c,
+       0x25, 0xb5, 0x15, 0xb3, 0x8b, 0xca, 0x85, 0x8c,
+       0xd6, 0x96, 0x0e, 0x74, 0x97, 0x27, 0x0e, 0x69,
+       0x29, 0x2a, 0x22, 0xfa, 0xe4, 0x52, 0x43, 0x63,
+       0x7d, 0x13, 0x29, 0x1d, 0x7a, 0xe2, 0x8d, 0x64,
+       0x68, 0x1a, 0x1a, 0x65, 0xa9, 0xbd, 0x19, 0x55,
+       0xbf, 0x34, 0x5b, 0xe5, 0x58, 0xc4, 0xc6, 0x18,
+       0x3f, 0x0c, 0x18, 0x0d, 0x97, 0x8a, 0xad, 0x69,
+       0x55, 0x14, 0x36, 0xcb, 0xb4, 0x35, 0x62, 0xe7,
+       0xb3, 0xdc, 0xad, 0x2d, 0x53, 0xb0, 0x0c, 0xcc,
+       0xe8, 0x50, 0x65, 0xa5, 0x4a, 0x54, 0x52, 0xb0,
+       0xac, 0xec, 0x29, 0x39, 0x96, 0xd2, 0x07, 0xd5,
+       0xcc, 0x25, 0x2d, 0xe8, 0x93, 0x4f, 0x29, 0xc1,
+       0x46, 0x70, 0x4f, 0x23, 0x60, 0x29, 0xcd, 0x1f,
+       0xce, 0x97, 0x69, 0xcd, 0x14, 0xbc, 0x3a, 0x72,
+       0x84, 0xa2, 0xaa, 0xb9, 0xac, 0x00, 0x4b, 0x49,
+       0x5b, 0x3d, 0x27, 0x62, 0x4b, 0xfe, 0x29, 0x4d,
+       0x0a, 0x0e, 0x98, 0x46, 0x81, 0xde, 0xaa, 0xb2,
+       0xd4, 0x48, 0x75, 0x3c, 0x49, 0xad, 0x50, 0x5d,
+       0xb3, 0xd4, 0x42, 0xd6, 0x4f, 0x42, 0xf6, 0x58,
+       0x96, 0xc5, 0x55, 0x51, 0x23, 0xa8, 0x34, 0xb7,
+       0x92, 0x31, 0x0e, 0xd5, 0x9e, 0xb2, 0xd2, 0x1a,
+       0xa1, 0xb8, 0xb1, 0x79, 0x38, 0x85, 0x74, 0x5b,
+       0x56, 0x1a, 0xd9, 0x10, 0x89, 0x0f, 0x61, 0xe2,
+       0x96, 0xd0, 0xe6, 0xfa, 0xeb, 0xa3, 0xf6, 0x49,
+       0x9b, 0xcf, 0x19, 0x49, 0x51, 0x8d, 0x0f, 0x7b,
+       0xad, 0xdd, 0x9f, 0xd9, 0x40, 0x6b, 0xe4, 0xa9,
+       0x02, 0xcb, 0xcc, 0xce, 0xbe, 0xd6, 0x8e, 0x27,
+       0x5f, 0xdc, 0xd4, 0xc6, 0xa6, 0x39, 0xce, 0x6c,
+       0x90, 0x92, 0x74, 0x1c, 0x59, 0xb5, 0xf1, 0xc9,
+       0x28, 0xd8, 0xea, 0x9f, 0x52, 0xd7, 0x1a, 0xa4,
+       0x55, 0x0e, 0xae, 0x8b, 0xd4, 0xee, 0xb1, 0xd0,
+       0x9a, 0x73, 0x66, 0x69, 0xad, 0xa0, 0x3a, 0xdc,
+       0x8b, 0x1b, 0x9b, 0xfd, 0xc3, 0x56, 0x9e, 0x16,
+       0xad, 0x7b, 0x04, 0x26, 0xfd, 0x21, 0x33, 0xb7,
+       0x2b, 0x10, 0x68, 0x7d, 0x02, 0x87, 0xfa, 0x2c,
+       0xaa, 0x4f, 0x7b, 0x0b, 0xcd, 0x1e, 0x8d, 0x0d,
+       0x02, 0xfb, 0x8a, 0x4f, 0x96, 0xa5, 0x7a, 0x71,
+       0x93, 0x4c, 0x33, 0x6d, 0xa9, 0xd4, 0x16, 0x64,
+       0x35, 0xb6, 0x64, 0x4f, 0x2e, 0x60, 0x6c, 0x2a,
+       0x90, 0x6e, 0xca, 0x5c, 0x46, 0xce, 0x88, 0x05,
+       0x4c, 0xe0, 0x2b, 0x40, 0xfc, 0x2b, 0x6b, 0xa1,
+       0xa9, 0xbf, 0x8d, 0x1c, 0xb3, 0x86, 0xf6, 0xe6,
+       0x56, 0xbe, 0xc0, 0xc3, 0xbf, 0xe2, 0xc6, 0xe1,
+       0xf8, 0x4c, 0x15, 0xcf, 0x55, 0x4d, 0x45, 0xce,
+       0xb9, 0x99, 0xd8, 0x3f, 0xf4, 0xfb, 0x41, 0x96,
+       0xf9, 0x37, 0x97, 0x31, 0x3c, 0xd9, 0xf5, 0x65,
+       0xb9, 0xf9, 0xb7, 0x86, 0x98, 0x53, 0x74, 0xdb,
+       0xec, 0x6a, 0xba, 0x36, 0x3a, 0xab, 0x1b, 0xf9,
+       0x64, 0x57, 0xa7, 0x7d, 0xd1, 0x88, 0x44, 0x8f,
+       0x3e, 0x4f, 0x9b, 0xe6, 0x7b, 0x91, 0xb7, 0xed,
+       0x51, 0x89, 0x55, 0xe5, 0xf5, 0xb8, 0x66, 0x69,
+       0x83, 0xa1, 0x64, 0x78, 0x4a, 0x89, 0xc7, 0xad,
+       0xa5, 0x78, 0xa8, 0x6b, 0xa8, 0x00, 0x3e, 0x4a,
+       0x68, 0x1a, 0xc6, 0xa1, 0xd2, 0x82, 0x8a, 0xa5,
+       0x12, 0x68, 0x3a, 0x56, 0xa4, 0x3a, 0x85, 0xad,
+       0xcd, 0xe4, 0xdb, 0xca, 0x43, 0x28, 0xb5, 0x31,
+       0x2a, 0x54, 0xd3, 0x0c, 0x33, 0xa5, 0x1a, 0x55,
+       0x42, 0xfb, 0x94, 0x12, 0xe9, 0x0a, 0x1b, 0x33,
+       0x4c, 0x23, 0xb4, 0x23, 0x85, 0x6f, 0x51, 0x07,
+       0xa6, 0x11, 0xf3, 0xcb, 0x6e, 0x67, 0x62, 0x98,
+       0x2d, 0x62, 0x65, 0x49, 0x75, 0x38, 0x81, 0x44,
+       0x79, 0x90, 0x86, 0xaa, 0xd3, 0xc8, 0x7c, 0x66,
+       0x7e, 0x54, 0x2f, 0xf4, 0xcf, 0x38, 0xa1, 0xf3,
+       0xab, 0x85, 0x5b, 0xdc, 0xd0, 0x2f, 0xf3, 0x42,
+       0xe7, 0x57, 0x15, 0x6b, 0x6b, 0xd2, 0xe6, 0xc6,
+       0x96, 0x9b, 0x3c, 0x43, 0x95, 0x5a, 0xbd, 0xdf,
+       0x46, 0x16, 0x72, 0x7e, 0x95, 0xef, 0x36, 0xe4,
+       0x2a, 0x81, 0x46, 0xcf, 0x5c, 0x1b, 0xf2, 0xb0,
+       0x70, 0x1d, 0x8c, 0x39, 0xe6, 0x7f, 0xcd, 0x1c,
+       0xe4, 0x83, 0xf1, 0x1c, 0xbe, 0xf9, 0x7f, 0x51,
+       0x19, 0x51, 0x0f, 0x8e, 0xe7, 0xae, 0x9e, 0x55,
+       0x74, 0x4b, 0xee, 0xb6, 0x96, 0x56, 0xec, 0x30,
+       0x35, 0x2f, 0xdd, 0xa9, 0x20, 0x0f, 0x0c, 0xfb,
+       0x18, 0x57, 0x46, 0x32, 0xbf, 0x31, 0x42, 0x7c,
+       0xd8, 0xbd, 0x98, 0xf9, 0x73, 0x6e, 0xd7, 0x45,
+       0xb8, 0x4c, 0x09, 0x6a, 0x07, 0x50, 0x5b, 0x6e,
+       0x5d, 0x4d, 0xde, 0x4c, 0x82, 0x23, 0x03, 0xd7,
+       0x1b, 0x0d, 0x8d, 0x75, 0xed, 0x8a, 0x90, 0x41,
+       0x37, 0x54, 0x48, 0xd8, 0x13, 0x2d, 0x00, 0x85,
+       0x1d, 0x63, 0x57, 0xac, 0x5e, 0x5d, 0x28, 0x17,
+       0x9a, 0x0e, 0x89, 0x87, 0x0e, 0x15, 0x76, 0xac,
+       0xe8, 0x28, 0x5c, 0x2d, 0xcb, 0x87, 0xde, 0x7a,
+       0xeb, 0x06, 0x1d, 0xa9, 0x08, 0x29, 0x20, 0xda,
+       0xad, 0xa2, 0x5d, 0xfb, 0xb0, 0x8a, 0x0a, 0x0b,
+       0xed, 0x85, 0x85, 0x29, 0xab, 0x53, 0x56, 0x17,
+       0x16, 0x42, 0x33, 0x46, 0x0b, 0x0c, 0x56, 0x07,
+       0xe2, 0xec, 0xf6, 0x66, 0x96, 0x58, 0x08, 0xd0,
+       0x01, 0x56, 0x87, 0x03, 0x64, 0x08, 0xdb, 0x29,
+       0x06, 0xf1, 0xda, 0x27, 0xb2, 0x65, 0xd9, 0xd1,
+       0x2c, 0x8a, 0xb2, 0x6c, 0x37, 0x1d, 0x15, 0xaf,
+       0x5c, 0x90, 0xe5, 0xa3, 0x18, 0xc4, 0xd2, 0x64,
+       0xd9, 0xca, 0x4a, 0x73, 0xd0, 0x67, 0xd0, 0x6f,
+       0x29, 0x4d, 0x2e, 0x90, 0xe5, 0x42, 0xd1, 0x61,
+       0x42, 0xda, 0x66, 0x19, 0xe4, 0x66, 0x93, 0xdd,
+       0x0e, 0xb2, 0xdd, 0x3e, 0x1d, 0x4b, 0xb3, 0xdb,
+       0x1d, 0x56, 0x93, 0x78, 0x08, 0xa1, 0x1d, 0x53,
+       0x44, 0xbb, 0x48, 0xaf, 0xda, 0xd9, 0xed, 0xab,
+       0xb5, 0xd2, 0x44, 0x59, 0xc4, 0xe2, 0xec, 0xa6,
+       0x93, 0xe2, 0x8d, 0xeb, 0x54, 0x9a, 0x9f, 0x4a,
+       0x2b, 0xc4, 0xea, 0x77, 0x14, 0x4e, 0x2f, 0xec,
+       0x98, 0xde, 0x61, 0xb7, 0xca, 0xf6, 0xcb, 0x1d,
+       0x14, 0x2a, 0xec, 0xc0, 0x94, 0x43, 0xf2, 0x6a,
+       0x68, 0x59, 0x61, 0x32, 0x35, 0x77, 0x88, 0x54,
+       0x1a, 0x36, 0xe5, 0xd5, 0xc5, 0x56, 0x87, 0x75,
+       0xb5, 0xc9, 0x61, 0x17, 0x6f, 0xf0, 0xd2, 0xec,
+       0xf6, 0x0f, 0x11, 0x5d, 0x08, 0x85, 0xe0, 0xe0,
+       0x6d, 0xa3, 0x92, 0xf9, 0xd3, 0xc9, 0x0e, 0x51,
+       0x5e, 0xb1, 0xa2, 0x65, 0xb5, 0xdd, 0xd4, 0x2b,
+       0x7e, 0xf0, 0xa1, 0xdc, 0x71, 0xb4, 0xa3, 0x10,
+       0x4b, 0xfb, 0x00, 0x33, 0x99, 0xb0, 0x1e, 0xb2,
+       0x03, 0x19, 0x5a, 0x9b, 0xed, 0x37, 0x64, 0xfa,
+       0x13, 0x31, 0x76, 0xa8, 0x19, 0x5b, 0xbd, 0xda,
+       0x6e, 0x4d, 0x39, 0x6a, 0xea, 0xb0, 0x16, 0x4e,
+       0x5f, 0x0d, 0x11, 0xf1, 0xe4, 0x72, 0x2c, 0x01,
+       0xac, 0x60, 0x2f, 0x6c, 0xa6, 0x26, 0x38, 0xac,
+       0xa2, 0xe9, 0x03, 0x90, 0x4d, 0xd8, 0x39, 0x32,
+       0x2b, 0x26, 0x02, 0xfe, 0x78, 0x79, 0x68, 0xdb,
+       0x64, 0xd6, 0xb6, 0x43, 0xc7, 0x64, 0xf1, 0x68,
+       0x73, 0xbc, 0x5d, 0x2e, 0xbc, 0x51, 0x68, 0x17,
+       0xa7, 0x63, 0xca, 0x6a, 0x56, 0xda, 0x0a, 0xfb,
+       0x07, 0xac, 0xb0, 0x42, 0x8c, 0x7d, 0x50, 0x80,
+       0xed, 0x59, 0x6e, 0xb7, 0x9b, 0x6e, 0x20, 0x2f,
+       0xd9, 0x84, 0x6d, 0x13, 0xf3, 0x4f, 0x3b, 0xb0,
+       0x6d, 0x76, 0x40, 0x1c, 0x13, 0x37, 0x6b, 0xdb,
+       0xea, 0xe9, 0xab, 0xe5, 0xe9, 0xb2, 0xd5, 0x4e,
+       0x4d, 0x1b, 0x6c, 0x5b, 0xb4, 0xdf, 0xe4, 0xa3,
+       0xa8, 0x25, 0xb2, 0x78, 0x9a, 0x82, 0x85, 0x57,
+       0x64, 0x7b, 0x98, 0xd5, 0xc3, 0x31, 0x9d, 0xb5,
+       0x0d, 0xfb, 0xb1, 0x63, 0xba, 0x68, 0x72, 0x60,
+       0x3d, 0x9a, 0x0b, 0xb1, 0xfb, 0xed, 0x0e, 0xd9,
+       0x4a, 0x84, 0x56, 0xec, 0x2f, 0x71, 0xc9, 0x31,
+       0xd1, 0xce, 0x7a, 0xb6, 0xa3, 0x99, 0xba, 0x8b,
+       0xfa, 0x2d, 0x8c, 0xfd, 0x85, 0x4c, 0xb1, 0x36,
+       0xa6, 0xe1, 0xa5, 0x91, 0x4e, 0x62, 0x3b, 0x0a,
+       0x0b, 0x0f, 0xad, 0x46, 0x9d, 0x14, 0x57, 0xcb,
+       0xd8, 0x63, 0xf6, 0x43, 0x6f, 0xd9, 0x6f, 0x4c,
+       0xa7, 0x7e, 0x43, 0x79, 0x5a, 0xad, 0xb2, 0xf5,
+       0x10, 0x2a, 0x85, 0x49, 0xec, 0x48, 0x99, 0x6e,
+       0x6f, 0x3e, 0x84, 0x3d, 0x5e, 0x68, 0x5f, 0x5d,
+       0x68, 0xa5, 0xae, 0x2d, 0x20, 0x1d, 0x3c, 0xfa,
+       0xcd, 0x30, 0xea, 0x24, 0xb6, 0xcd, 0xce, 0x4a,
+       0xa3, 0x9e, 0x5a, 0x61, 0xc7, 0xbc, 0x85, 0xd3,
+       0xa7, 0x1b, 0x58, 0xdb, 0xcc, 0xf1, 0xfe, 0xd5,
+       0x5f, 0xef, 0x49, 0x0b, 0x65, 0xe5, 0x8f, 0x37,
+       0x4d, 0x37, 0x29, 0xa6, 0xf6, 0x67, 0x1f, 0xf6,
+       0xf1, 0x21, 0xc7, 0x2d, 0x1c, 0x6e, 0xfc, 0xbf,
+       0xf2, 0x50, 0x4a, 0x0f, 0xd3, 0x18, 0x0c, 0xc1,
+       0x7f, 0x83, 0x7f, 0x80, 0x7f, 0x81, 0x43, 0xf0,
+       0xaf, 0xf0, 0x85, 0x6e, 0xb4, 0xee, 0x4e, 0xdd,
+       0x24, 0xdd, 0x34, 0x5d, 0x95, 0xae, 0x55, 0xf7,
+       0xed, 0x5b, 0xbe, 0xca, 0xf5, 0x8f, 0xba, 0x9d,
+       0xba, 0x5f, 0xe9, 0xae, 0xeb, 0xc7, 0xeb, 0x67,
+       0xe8, 0x45, 0xfd, 0x93, 0xfa, 0x67, 0xf5, 0xcf,
+       0xeb, 0x5f, 0xd4, 0xbf, 0xac, 0x7f, 0x4d, 0xbf,
+       0x5b, 0xff, 0xa6, 0xfe, 0x90, 0xfe, 0x98, 0xfe,
+       0x03, 0xfd, 0x87, 0xfa, 0x4f, 0xf4, 0xbd, 0xfa,
+       0xcf, 0x0d, 0x7a, 0xc3, 0x08, 0x43, 0xa2, 0xa1,
+       0xd0, 0x50, 0x69, 0x10, 0x0d, 0xcb, 0x0c, 0xab,
+       0x0d, 0xeb, 0x0d, 0xff, 0x60, 0xf8, 0x91, 0xe1,
+       0x67, 0x86, 0x8b, 0x00, 0x46, 0x8b, 0x71, 0x92,
+       0x8b, 0x1d, 0xec, 0x8f, 0x8e, 0x0a, 0xbd, 0x40,
+       0xeb, 0x52, 0xd7, 0x2f, 0x25, 0xf4, 0x5c, 0x25,
+       0xfa, 0x44, 0xa0, 0x6c, 0xf0, 0x06, 0x18, 0x94,
+       0xa1, 0x27, 0xaa, 0xa0, 0xa3, 0x54, 0x8c, 0xcb,
+       0x04, 0x74, 0x61, 0xeb, 0x56, 0x0a, 0x0b, 0x1b,
+       0x03, 0xad, 0x50, 0xe4, 0x29, 0x47, 0xaf, 0xbe,
+       0x3c, 0x67, 0x18, 0x6d, 0x8d, 0xcf, 0x55, 0x35,
+       0x2f, 0x93, 0xae, 0xf5, 0xf5, 0x99, 0xf5, 0x7e,
+       0x1e, 0x18, 0x46, 0x51, 0x85, 0xcb, 0x66, 0xb4,
+       0xa9, 0x38, 0x5b, 0xcf, 0x6b, 0x6a, 0x6d, 0x96,
+       0x78, 0x2e, 0x72, 0x70, 0xa1, 0x02, 0x5d, 0x3f,
+       0x21, 0xdb, 0x81, 0xbe, 0x57, 0xc9, 0x32, 0x5a,
+       0xa4, 0x63, 0x75, 0x38, 0x0a, 0xff, 0x06, 0x51,
+       0x5a, 0x80, 0x9e, 0xf7, 0x34, 0xb2, 0x07, 0x53,
+       0x50, 0xd4, 0x8a, 0x93, 0x0c, 0x35, 0x09, 0xb1,
+       0xb8, 0xa2, 0x09, 0xb6, 0xa2, 0x1f, 0x30, 0x84,
+       0x3b, 0xce, 0xfc, 0xf5, 0x4b, 0xe5, 0x00, 0x4d,
+       0xab, 0xa5, 0xfc, 0x76, 0x15, 0x6f, 0xeb, 0xdc,
+       0x96, 0xa6, 0x16, 0x9c, 0x7b, 0xa4, 0xe6, 0xa6,
+       0x55, 0xe8, 0xc5, 0x0d, 0xb2, 0xab, 0xf6, 0xb7,
+       0x07, 0x9a, 0x5a, 0xdb, 0xdb, 0x86, 0xa0, 0x2a,
+       0x1a, 0x97, 0xa3, 0xa7, 0x91, 0x2d, 0xb8, 0xda,
+       0x83, 0xad, 0x7c, 0x2d, 0x29, 0x64, 0xd4, 0xb8,
+       0x4b, 0xa6, 0x14, 0x57, 0x97, 0xbb, 0x2b, 0xca,
+       0xa7, 0x54, 0xcf, 0x2e, 0xad, 0x99, 0xa8, 0x12,
+       0xe5, 0x0c, 0x23, 0x2a, 0x2a, 0x73, 0x4d, 0x76,
+       0x4d, 0x29, 0xa9, 0x8d, 0x26, 0xe7, 0x0e, 0x4f,
+       0x9e, 0x5d, 0x55, 0x55, 0xe2, 0x9b, 0x32, 0xcf,
+       0x5d, 0xe1, 0xaa, 0x2c, 0x9f, 0xe2, 0xae, 0x28,
+       0xab, 0xa9, 0x29, 0xf1, 0x69, 0xa4, 0x79, 0xc3,
+       0x48, 0x5d, 0x73, 0x8b, 0xcb, 0x66, 0x3b, 0x26,
+       0xe7, 0x6a, 0xa9, 0x0f, 0x0c, 0x4b, 0xf5, 0xb9,
+       0x4b, 0xa9, 0x32, 0xd5, 0x0b, 0x2a, 0x8b, 0x34,
+       0x82, 0xfc, 0x5b, 0x2a, 0xe2, 0xe6, 0x15, 0xa9,
+       0x9c, 0x55, 0x36, 0x24, 0x89, 0x75, 0x99, 0x30,
+       0xc1, 0xa1, 0xc2, 0x6c, 0x15, 0xe6, 0xa8, 0x30,
+       0x57, 0x85, 0x79, 0x2a, 0x7c, 0x40, 0x85, 0xf9,
+       0x2a, 0x7c, 0x50, 0x85, 0x05, 0x2a, 0x7c, 0x48,
+       0xe3, 0x13, 0x65, 0xa8, 0x71, 0xcc, 0xd6, 0x58,
+       0x66, 0x6b, 0x3c, 0xb3, 0x35, 0xa6, 0xd9, 0x0f,
+       0x40, 0x69, 0x15, 0xae, 0x58, 0xa4, 0x16, 0xf4,
+       0xf2, 0xb0, 0xb6, 0xe4, 0x50, 0xe2, 0x44, 0x3f,
+       0x17, 0xd7, 0x2e, 0x0d, 0x8d, 0x01, 0xec, 0x9c,
+       0xa2, 0xd6, 0x96, 0x06, 0x76, 0x1b, 0x85, 0xe8,
+       0xca, 0x5a, 0x70, 0x4d, 0x86, 0x1e, 0x85, 0xaf,
+       0xb1, 0x8d, 0x14, 0x18, 0x31, 0x37, 0x69, 0x26,
+       0x62, 0xe6, 0xb6, 0x60, 0x46, 0xb9, 0xb9, 0xf5,
+       0x09, 0x8a, 0xcc, 0x46, 0xdf, 0x9d, 0x5c, 0x0d,
+       0xde, 0xed, 0x84, 0x58, 0x3e, 0x98, 0x58, 0x8d,
+       0x4b, 0x24, 0x54, 0x01, 0xf4, 0x22, 0x2a, 0x5d,
+       0x95, 0x3c, 0x6b, 0xd3, 0x32, 0x7f, 0x73, 0xe3,
+       0x32, 0x5c, 0x8d, 0x60, 0xc9, 0xc5, 0x52, 0x50,
+       0xa2, 0x47, 0x20, 0x30, 0x6b, 0xd6, 0x5c, 0xaa,
+       0x86, 0xdc, 0xa4, 0xb4, 0x07, 0xf8, 0x9d, 0x20,
+       0xce, 0x8e, 0xf0, 0xda, 0xa8, 0x61, 0x05, 0xdd,
+       0x94, 0xa6, 0x0e, 0x36, 0xde, 0x27, 0x51, 0xa5,
+       0x1c, 0x54, 0xc1, 0x21, 0x65, 0x95, 0xc8, 0x72,
+       0x23, 0x7f, 0x3c, 0xab, 0x0e, 0xca, 0x9b, 0xd2,
+       0xb5, 0x81, 0x38, 0x74, 0x38, 0x75, 0x55, 0x2d,
+       0xb3, 0x77, 0x2d, 0x06, 0x7d, 0x4b, 0x42, 0x0e,
+       0x6c, 0xac, 0x3a, 0xee, 0xca, 0x71, 0xd8, 0xcc,
+       0x8a, 0xa9, 0x7b, 0xbf, 0x60, 0xae, 0x6c, 0x17,
+       0x16, 0x83, 0x31, 0xd5, 0x2c, 0x9f, 0xf6, 0x03,
+       0x7d, 0x01, 0x90, 0xed, 0x05, 0xd0, 0x0f, 0x7d,
+       0xb9, 0x97, 0x2e, 0xcf, 0xcc, 0x8c, 0x64, 0xfc,
+       0xf5, 0x3d, 0xe7, 0xaf, 0xfe, 0xe3, 0xdf, 0xf5,
+       0x36, 0xfc, 0x97, 0xef, 0xa5, 0x30, 0xf1, 0x3b,
+       0x14, 0x5f, 0x83, 0xf2, 0x8e, 0x72, 0xac, 0xdf,
+       0x74, 0xa0, 0x83, 0x41, 0xa3, 0x61, 0xc3, 0x99,
+       0xc1, 0x74, 0x56, 0x77, 0xdd, 0x77, 0xc7, 0x19,
+       0x9f, 0x8e, 0xfc, 0x97, 0xfe, 0xcd, 0xf8, 0x2f,
+       0x2d, 0x8d, 0x35, 0x35, 0xee, 0xf1, 0xcd, 0x78,
+       0x75, 0xfe, 0xc5, 0xc2, 0xe6, 0xf9, 0xcc, 0x2c,
+       0x6f, 0x9c, 0xf7, 0x69, 0x88, 0x33, 0xef, 0x8b,
+       0x55, 0x53, 0xcc, 0x3b, 0x40, 0x60, 0x9f, 0x4a,
+       0xbc, 0x1f, 0xaf, 0x71, 0x8f, 0xee, 0xd3, 0x57,
+       0xc0, 0xf8, 0x94, 0x31, 0xa9, 0x1f, 0x82, 0xf9,
+       0xd5, 0xdf, 0x41, 0x5c, 0xec, 0x00, 0xa3, 0xc7,
+       0xbf, 0x7b, 0xe9, 0x1c, 0x1c, 0x96, 0xff, 0xd1,
+       0xdb, 0xe7, 0xff, 0x9f, 0x2c, 0xff, 0x40, 0x34,
+       0xbf, 0xe9, 0x74, 0x0a, 0xcf, 0xff, 0xe8, 0xd3,
+       0x83, 0xf5, 0xb8, 0xd7, 0x0f, 0xa3, 0xeb, 0x0f,
+       0x68, 0xd3, 0x3e, 0xd6, 0x6b, 0x8f, 0xfa, 0x4d,
+       0x35, 0xe2, 0x7b, 0xf0, 0xb6, 0x7c, 0xef, 0x25,
+       0xbe, 0x8f, 0xd5, 0x44, 0xf9, 0xc6, 0xe8, 0x7e,
+       0xaf, 0xf2, 0x3d, 0x48, 0xc9, 0xc5, 0x7c, 0xd8,
+       0x3b, 0xdd, 0x15, 0x35, 0xc5, 0xc5, 0xae, 0x1a,
+       0xa1, 0x78, 0x96, 0xab, 0x68, 0x76, 0xa5, 0x4f,
+       0x98, 0x57, 0x35, 0xbb, 0x9a, 0x96, 0x85, 0xf3,
+       0x3c, 0x3c, 0x80, 0x13, 0x08, 0x26, 0xfb, 0x04,
+       0xef, 0xec, 0x05, 0x0e, 0xa2, 0x43, 0x98, 0x4d,
+       0xb0, 0xa8, 0xa2, 0x96, 0x80, 0xe0, 0x2a, 0x2e,
+       0x67, 0xf9, 0xaa, 0x66, 0xd7, 0xb0, 0x74, 0x84,
+       0xd9, 0x2a, 0x2c, 0xab, 0xac, 0xc2, 0x25, 0x76,
+       0x89, 0x8f, 0xe5, 0xa7, 0x59, 0x71, 0x01, 0xc2,
+       0xb2, 0xca, 0x9a, 0x92, 0x4a, 0x17, 0x83, 0xbe,
+       0x92, 0x39, 0x0c, 0x5f, 0x55, 0xe3, 0x11, 0x38,
+       0xac, 0x60, 0xb0, 0xa2, 0xa4, 0x52, 0x2b, 0x57,
+       0x10, 0x7c, 0x25, 0xa5, 0x55, 0x98, 0x8d, 0xd5,
+       0x6b, 0xbe, 0x56, 0x2f, 0x0c, 0xe0, 0x2c, 0x89,
+       0xe5, 0x6a, 0xfc, 0x19, 0xac, 0xa2, 0x5b, 0x83,
+       0x58, 0xee, 0x4c, 0x7a, 0x74, 0x8c, 0xf5, 0xac,
+       0x29, 0xa9, 0xae, 0x11, 0xaa, 0xa9, 0x98, 0xb9,
+       0x02, 0x41, 0x9c, 0x51, 0x19, 0xf4, 0xd0, 0xb3,
+       0x30, 0x84, 0x15, 0xb3, 0x2b, 0x67, 0x0a, 0xd8,
+       0x7e, 0xe4, 0xe3, 0x50, 0x61, 0x36, 0x41, 0x57,
+       0xe9, 0xfc, 0x59, 0x0c, 0x56, 0x70, 0x58, 0x44,
+       0x15, 0xe4, 0xb0, 0x82, 0xa0, 0x5b, 0x8d, 0xbb,
+       0xd5, 0xb8, 0x4b, 0x8d, 0xbb, 0xd4, 0x78, 0xb1,
+       0x1a, 0x2f, 0x56, 0xe3, 0xd5, 0x65, 0x0b, 0x4b,
+       0xb4, 0x72, 0x2a, 0x78, 0x7c, 0x9e, 0x8a, 0xe7,
+       0x7c, 0x67, 0xcd, 0x2e, 0x66, 0xfc, 0x54, 0xe8,
+       0x52, 0x61, 0x31, 0x41, 0x5f, 0x09, 0xb6, 0x6c,
+       0x5e, 0x49, 0xf1, 0x97, 0x41, 0xca, 0x4f, 0x02,
+       0xa0, 0xfc, 0x2a, 0x74, 0x11, 0xd4, 0xd2, 0xab,
+       0xab, 0x7c, 0x1e, 0x86, 0xaf, 0xaa, 0x60, 0xb0,
+       0xa2, 0xac, 0xda, 0x55, 0x56, 0xcc, 0xe4, 0x4b,
+       0x8e, 0x01, 0xc9, 0x31, 0xbb, 0xa2, 0xc8, 0xa3,
+       0xc2, 0x0a, 0x82, 0x39, 0x6a, 0x3c, 0x47, 0x8d,
+       0x7b, 0x67, 0x55, 0x65, 0xab, 0x30, 0x87, 0x60,
+       0x59, 0x65, 0x35, 0xe6, 0x2f, 0x9b, 0x8f, 0x22,
+       0xac, 0xe1, 0x70, 0x36, 0x4e, 0xb7, 0xc5, 0xa5,
+       0x3c, 0x4e, 0x90, 0xe2, 0x4c, 0x9f, 0x04, 0xd2,
+       0x13, 0x06, 0x79, 0xbf, 0x0b, 0x6a, 0xbf, 0x6b,
+       0x7a, 0x83, 0x70, 0x6e, 0xb1, 0x83, 0xca, 0xe3,
+       0xb0, 0x82, 0x43, 0x54, 0x00, 0x82, 0xd4, 0xa1,
+       0x04, 0xe7, 0xcd, 0xe6, 0xf8, 0xa1, 0xed, 0xd2,
+       0x20, 0xe2, 0xb3, 0xd5, 0xfc, 0xd9, 0x6a, 0xfe,
+       0x6c, 0x35, 0x7f, 0xb6, 0x9a, 0x3f, 0x5b, 0xcd,
+       0x9f, 0xfd, 0x25, 0xf9, 0x73, 0xd4, 0xfc, 0x39,
+       0x6a, 0xfe, 0x1c, 0x35, 0x7f, 0x8e, 0x9a, 0x3f,
+       0x47, 0xcd, 0x9f, 0xf3, 0x25, 0xf9, 0x73, 0xd5,
+       0xfc, 0xb9, 0x6a, 0xfe, 0x5c, 0x35, 0x7f, 0xae,
+       0x9a, 0x3f, 0x57, 0xcd, 0x9f, 0x7b, 0xbb, 0xfc,
+       0xd8, 0x2f, 0xd9, 0x4c, 0x5f, 0x18, 0xac, 0x20,
+       0x98, 0xa3, 0xc6, 0x73, 0xd4, 0x78, 0xae, 0x1a,
+       0xcf, 0x55, 0xe3, 0x79, 0x6a, 0x3c, 0x4f, 0x8d,
+       0x3f, 0xa0, 0xc6, 0x1f, 0x50, 0xe3, 0xf9, 0x6a,
+       0x3c, 0x5f, 0x8d, 0x3f, 0xa8, 0xc6, 0x1f, 0x54,
+       0xe3, 0x05, 0x6a, 0xbc, 0x40, 0x8d, 0x73, 0xfd,
+       0x67, 0x30, 0x5b, 0x85, 0x39, 0x2a, 0xcc, 0x65,
+       0xf5, 0x62, 0xfa, 0x88, 0xf5, 0x51, 0x21, 0xe2,
+       0xf3, 0xd4, 0x7e, 0x65, 0x74, 0xd9, 0xaa, 0x7e,
+       0xe5, 0xa8, 0x30, 0x57, 0x85, 0x79, 0x2a, 0x7c,
+       0x40, 0x85, 0xf9, 0x2a, 0x7c, 0x50, 0x85, 0x05,
+       0x04, 0x51, 0x3f, 0x1d, 0x54, 0x1f, 0x0e, 0x2b,
+       0x08, 0x66, 0xab, 0xf1, 0x6c, 0x35, 0x9e, 0xa3,
+       0xc6, 0x73, 0xd4, 0x78, 0xae, 0x1a, 0xcf, 0x55,
+       0xe3, 0x79, 0x6a, 0x3c, 0x4f, 0x8d, 0x3f, 0xa0,
+       0xc6, 0x1f, 0x50, 0xe3, 0xf9, 0x6a, 0x3c, 0x5f,
+       0x8d, 0x3f, 0xa8, 0xc6, 0x1f, 0x54, 0xe3, 0x0e,
+       0xb4, 0x28, 0x0c, 0x16, 0xa9, 0x71, 0xac, 0x97,
+       0x4b, 0x85, 0x6e, 0x56, 0x0f, 0x9e, 0x9e, 0xad,
+       0xa6, 0x67, 0xab, 0xe9, 0xd9, 0x6a, 0x7a, 0x8e,
+       0x9a, 0x9e, 0xa3, 0xa6, 0xe7, 0xa8, 0xe9, 0x39,
+       0x6a, 0x7a, 0xae, 0x9a, 0x9e, 0xab, 0xa6, 0xe7,
+       0xaa, 0xe9, 0xb9, 0x6a, 0x7a, 0x9e, 0x9a, 0x9e,
+       0xa7, 0xa6, 0xe7, 0xa9, 0xe9, 0x79, 0x6a, 0xfa,
+       0x03, 0x6a, 0xfa, 0x03, 0x6a, 0xfa, 0x03, 0x6a,
+       0xfa, 0x03, 0x6a, 0x7a, 0xbe, 0x9a, 0x9e, 0xaf,
+       0xa6, 0xe7, 0xab, 0xe9, 0xf9, 0x6a, 0xfa, 0x83,
+       0x6a, 0xfa, 0x83, 0x6a, 0xfa, 0x83, 0x6a, 0x3a,
+       0x41, 0x77, 0xd1, 0xec, 0x8a, 0xd9, 0x3e, 0x87,
+       0x43, 0xe0, 0x30, 0x5b, 0x85, 0x39, 0x2a, 0xcc,
+       0x55, 0x61, 0x9e, 0x0a, 0x1f, 0x50, 0x61, 0xbe,
+       0x0a, 0x1f, 0x54, 0x61, 0x81, 0x0a, 0x1f, 0x52,
+       0xa1, 0x4b, 0x85, 0x6e, 0x15, 0x16, 0xa9, 0xb0,
+       0x58, 0x85, 0x25, 0x2a, 0x2c, 0xe5, 0x30, 0x5b,
+       0x2d, 0x3f, 0x5b, 0x2d, 0x3f, 0x5b, 0x2d, 0x3f,
+       0x5b, 0x2d, 0x3f, 0x5b, 0x2d, 0x3f, 0x5b, 0x2d,
+       0x3f, 0x5b, 0x2d, 0x3f, 0x5b, 0x2d, 0x3f, 0x5b,
+       0x2d, 0x3f, 0x5b, 0x2d, 0x3f, 0x5b, 0x2d, 0x3f,
+       0x5b, 0x2d, 0x3f, 0x5b, 0x2d, 0x3f, 0x5b, 0x2d,
+       0x3f, 0x5b, 0x2d, 0x3f, 0xbb, 0x54, 0xf0, 0xd4,
+       0xcc, 0xae, 0xa1, 0x67, 0x6c, 0x9e, 0x6a, 0x66,
+       0xb6, 0x04, 0x8f, 0x9b, 0x99, 0x31, 0x06, 0x29,
+       0x3e, 0x4f, 0x4d, 0x9f, 0xa7, 0xa6, 0xcf, 0x53,
+       0xd3, 0xe7, 0xa9, 0xe9, 0x64, 0x5f, 0x09, 0xc3,
+       0xe1, 0xec, 0x2a, 0xb2, 0xb3, 0x14, 0xe7, 0x70,
+       0x76, 0x95, 0x47, 0x9d, 0xaf, 0x3c, 0xea, 0x7c,
+       0xea, 0x2e, 0x71, 0xcd, 0xa2, 0x01, 0x47, 0xe5,
+       0x31, 0x3e, 0x2a, 0xf4, 0x14, 0x95, 0xa0, 0x85,
+       0xf4, 0x91, 0x3d, 0xf5, 0x94, 0xcd, 0x64, 0xe3,
+       0xd3, 0x43, 0xe3, 0x8d, 0xf8, 0xaa, 0xfa, 0xea,
+       0x51, 0xc7, 0xab, 0x47, 0x1d, 0xbf, 0x2c, 0xfe,
+       0xe7, 0xe6, 0x87, 0x9b, 0x61, 0x29, 0x32, 0xa5,
+       0x9b, 0xeb, 0x95, 0xb3, 0xf9, 0xf3, 0xd1, 0xff,
+       0xef, 0x3c, 0x68, 0x75, 0x1f, 0xb2, 0x7e, 0xf0,
+       0x8d, 0x9c, 0xf8, 0x4e, 0xd8, 0xae, 0x14, 0xf2,
+       0xdf, 0x13, 0x1d, 0xb0, 0xfd, 0xdb, 0xfb, 0xbe,
+       0x24, 0xeb, 0xb6, 0xf1, 0x8b, 0xbf, 0x56, 0x11,
+       0x4f, 0xfe, 0x75, 0x9d, 0xf2, 0xd7, 0xbf, 0xbf,
+       0xfe, 0xfd, 0xf5, 0xef, 0xaf, 0x7f, 0xff, 0x97,
+       0xfd, 0x25, 0x69, 0x81, 0x62, 0xc7, 0xb4, 0x15,
+       0xea, 0x9f, 0xf0, 0x1f, 0x0b, 0x58, 0x5c, 0xff,
+       0x79, 0xac, 0xaa, 0x8a, 0x06, 0x59, 0x09, 0xd5,
+       0xd5, 0x55, 0x83, 0xb1, 0xb9, 0x43, 0x23, 0xf3,
+       0xdc, 0xbe, 0xc1, 0x48, 0x35, 0x0f, 0x0b, 0xe8,
+       0x2b, 0x44, 0x91, 0x96, 0xff, 0x5f, 0x7b, 0x77,
+       0x93, 0xd2, 0x30, 0x10, 0x86, 0x01, 0x78, 0xc4,
+       0x5d, 0xbd, 0x44, 0x17, 0x85, 0xee, 0x24, 0x6d,
+       0xa1, 0x48, 0x77, 0xa5, 0xa5, 0xe8, 0xa2, 0x28,
+       0x2e, 0xdc, 0x94, 0x20, 0x45, 0xea, 0x0f, 0x16,
+       0x91, 0xa2, 0x17, 0xf1, 0x06, 0x1e, 0xc3, 0x2b,
+       0x78, 0x0a, 0x6f, 0xa2, 0x6d, 0x8d, 0x26, 0x56,
+       0xad, 0x06, 0xa2, 0x52, 0x79, 0x9e, 0x45, 0xc8,
+       0x84, 0x64, 0x48, 0x66, 0x16, 0x09, 0x6f, 0xc8,
+       0x97, 0x9d, 0xec, 0xee, 0xfd, 0x6c, 0xa3, 0xd3,
+       0xee, 0xec, 0x67, 0x5b, 0xed, 0x4c, 0xab, 0xdf,
+       0x69, 0x6e, 0x45, 0xcd, 0xa8, 0x14, 0x4e, 0xcb,
+       0x95, 0xd7, 0x8d, 0x95, 0x9c, 0xcb, 0xea, 0xe2,
+       0x5b, 0xcf, 0x6a, 0x29, 0x14, 0xff, 0x6d, 0x50,
+       0x29, 0xfc, 0x4c, 0x8f, 0x8f, 0x2b, 0x24, 0x84,
+       0xec, 0x30, 0x67, 0x9e, 0x7d, 0x72, 0x67, 0x8e,
+       0xe9, 0x71, 0xe9, 0xbc, 0xff, 0xf1, 0xf3, 0xdb,
+       0xbb, 0x4c, 0x34, 0xcf, 0xf1, 0x1f, 0x8f, 0x43,
+       0x9a, 0xdc, 0xad, 0xee, 0x5a, 0xea, 0x8b, 0xb9,
+       0x5e, 0x5f, 0xb8, 0xf6, 0x10, 0x36, 0x96, 0x8d,
+       0x4d, 0x26, 0x09, 0x7e, 0x08, 0xb7, 0x37, 0xf7,
+       0x49, 0x27, 0xdd, 0x5e, 0x54, 0x50, 0xbe, 0xfc,
+       0xdc, 0xeb, 0x5a, 0xd2, 0x6b, 0xcd, 0xad, 0x08,
+       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xc7,
+       0xb2, 0xb7, 0xcc, 0x00, 0x00, 0x00, 0xc0, 0xf7,
+       0xdc, 0x15, 0x2c, 0xa9, 0x50, 0x79, 0x50, 0xdf,
+       0x6c, 0x34, 0x66, 0x85, 0x49, 0xda, 0xe3, 0xe1,
+       0xd9, 0x45, 0xb9, 0x3f, 0x1c, 0x8f, 0xce, 0x73,
+       0x9e, 0xd9, 0xde, 0xf0, 0x64, 0x74, 0x58, 0x9b,
+       0xff, 0x8a, 0xa1, 0x35, 0x88, 0xa2, 0xb8, 0xdc,
+       0x9d, 0x15, 0x9e, 0x9d, 0xae, 0xc6, 0x2f, 0x65,
+       0x42, 0x5a, 0x83, 0x4a, 0x94, 0x88, 0xcb, 0xdb,
+       0x93, 0xab, 0x37, 0xed, 0xde, 0xd1, 0xe5, 0x75,
+       0x6b, 0x30, 0xaf, 0x12, 0x19, 0xcf, 0x4a, 0xf9,
+       0x4d, 0xf7, 0xde, 0x3d, 0x3e, 0x8e, 0xcd, 0x38,
+       0x00, 0x00, 0x00, 0xfc, 0xbb, 0xfc, 0xa0, 0x2e,
+       0x3f, 0x00, 0x00, 0x00, 0x00, 0xf9, 0xc1, 0xe7,
+       0xe6, 0x3f, 0xe7, 0x99, 0x14, 0x9d, 0x1f, 0xf8,
+       0xa2, 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,
@@ -5208,9 +5223,8 @@ unsigned char hrtrom[] = {
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-       0xa0, 0x2f, 0x77, 0x30, 0xd8, 0x2c, 0x3f, 0x5c,
-       0x06, 0x03, 0x00
+       0x00, 0x00, 0x00, 0x00, 0x28, 0xca, 0x13, 0x7a,
+       0x06, 0x18, 0xa1, 0x1c, 0x07, 0x03, 0x00
 };
 
-unsigned int hrtrom_len = 41691;
+unsigned int hrtrom_len = 41807;

diff --git a/include/events.h b/include/events.h
index 8f41d7dda7a9b62dbc29aa1d199194ea2aedccf3..a8378862d2f23e133531d0607deb737ae315f796 100644 (file)
--- a/include/events.h
+++ b/include/events.h
@@ -36,14 +36,14 @@ typedef unsigned long int evt;
 
 struct ev
 {
-    int active;
+    bool active;
     evt evtime, oldcycles;
     evfunc handler;
 };
 
 struct ev2
 {
-    int active;
+    bool active;
     evt evtime;
     uae_u32 data;
     evfunc2 handler;

diff --git a/main.cpp b/main.cpp
index 7212e2def73a7c6711ce4a725182ec4039714d8c..d796c56d7361df60f5be1f09645e73cd9516681b 100644 (file)
--- a/main.cpp
+++ b/main.cpp
@@ -133,10 +133,6 @@ void fixup_prefs_dimensions (struct uae_prefs *prefs)
        fixup_prefs_dim2 (&prefs->gfx_size_win);
        if (prefs->gfx_filter == 0 && prefs->gfx_filter_autoscale && !prefs->gfx_api)
                prefs->gfx_filter = 1;
-       if (prefs->gfx_filter_autoscale == AUTOSCALE_RESIZE || prefs->gfx_filter_autoscale == AUTOSCALE_CENTER) {
-               prefs->gfx_filter_horiz_zoom_mult = 0;
-               prefs->gfx_filter_vert_zoom_mult = 0;
-       }
 }
 
 void fixup_cpu (struct uae_prefs *p)

diff --git a/memory.cpp b/memory.cpp
index 0236dacd13f0972477868486c7774eb2c3ac1e86..b44280767bd9c6c556e2c1eeb09aae68ef2237aa 100644 (file)
--- a/memory.cpp
+++ b/memory.cpp
@@ -2126,7 +2126,7 @@ static void allocate_memory (void)
                bogomemory_allocated = 0;
 
                allocated_bogomem = currprefs.bogomem_size;
-               if (allocated_bogomem == 0x180000)
+               if (allocated_bogomem >= 0x180000)
                        allocated_bogomem = 0x200000;
                bogomem_mask = allocated_bogomem - 1;
 
@@ -2460,7 +2460,7 @@ void memory_reset (void)
                int t = currprefs.bogomem_size >> 16;
                if (t > 0x1C)
                        t = 0x1C;
-               if (t > 0x10 && ((currprefs.chipset_mask & CSMASK_AGA) || currprefs.cpu_model >= 68020))
+               if (t > 0x10 && ((currprefs.chipset_mask & CSMASK_AGA) || (currprefs.cpu_model >= 68020 && !currprefs.address_space_24)))
                        t = 0x10;
                map_banks (&bogomem_bank, 0xC0, t, 0);
        }

diff --git a/newcpu.cpp b/newcpu.cpp
index 7d31932939255580b455c7c8c7e80a44f966733c..a097c54ff50aeaaf6c4d6f8abc56149b9f727a0a 100644 (file)
--- a/newcpu.cpp
+++ b/newcpu.cpp
@@ -2997,7 +2997,7 @@ unsigned long REGPARAM2 op_illg (uae_u32 opcode)
        if ((opcode & 0xF000) == 0xF000) {
                if (warned < 20) {
                        //write_log (L"B-Trap %x at %x (%p)\n", opcode, pc, regs.pc_p);
-                       warned++;
+                       //warned++;
                }
                Exception (0xB);
                //activate_debugger ();
@@ -3006,7 +3006,7 @@ unsigned long REGPARAM2 op_illg (uae_u32 opcode)
        if ((opcode & 0xF000) == 0xA000) {
                if (warned < 20) {
                        //write_log (L"A-Trap %x at %x (%p)\n", opcode, pc, regs.pc_p);
-                       warned++;
+                       //warned++;
                }
                Exception (0xA);
                //activate_debugger();
@@ -3279,8 +3279,6 @@ STATIC_INLINE int do_specialties (int cycles)
                        hrtmon_breakenter ();
                if (hrtmon_flag == ACTION_REPLAY_ACTIVATE)
                        hrtmon_enter ();
-               if (!(regs.spcflags & ~SPCFLAG_ACTION_REPLAY))
-                       return 0;
        }
 #endif
        if ((regs.spcflags & SPCFLAG_ACTION_REPLAY) && action_replay_flag != ACTION_REPLAY_INACTIVE) {
@@ -4031,6 +4029,9 @@ static void m68k_run_2 (void)
                uae_u16 opcode = get_iword (0);
                count_instr (opcode);
 
+//             if (regs.s == 0 && regs.regs[15] < 0x10040000 && regs.regs[15] > 0x10000000)
+//                     activate_debugger();
+
 #if 0
                if (!used[opcode]) {
                        write_log (L"%04X ", opcode);

diff --git a/od-win32/caps/caps_win32.cpp b/od-win32/caps/caps_win32.cpp
index 4e7f2579b3ce98c40939675e08a94b3618a7299c..591814e47bacd00f61232f16bcc87c3c8b1a6ff7 100644 (file)
--- a/od-win32/caps/caps_win32.cpp
+++ b/od-win32/caps/caps_win32.cpp
@@ -196,15 +196,17 @@ static void mfmcopy (uae_u16 *mfm, uae_u8 *data, int len)
        }
 }
 
-static int load (struct CapsTrackInfoT2 *ci, int drv, int track)
+static int load (struct CapsTrackInfoT2 *ci, int drv, int track, bool seed)
 {
        int flags;
        
        flags = caps_flags;
        if (canseed) {
-               flags |= DI_LOCK_SETWSEED;
                ci->type = 2;
-               ci->wseed = uaerand ();
+               if (seed) {
+                       flags |= DI_LOCK_SETWSEED;
+                       ci->wseed = uaerand ();
+               }
        } else {
                ci->type = 1;
        }
@@ -218,7 +220,7 @@ int caps_loadrevolution (uae_u16 *mfmbuf, int drv, int track, int *tracklength)
        int len;
        struct CapsTrackInfoT2 ci;
 
-       if (!load (&ci, drv, track))
+       if (!load (&ci, drv, track, false))
                return 0;
        if (oldlib)
                len = ci.tracklen * 8;
@@ -236,7 +238,7 @@ int caps_loadtrack (uae_u16 *mfmbuf, uae_u16 *tracktiming, int drv, int track, i
 
        if (tracktiming)
                *tracktiming = 0;
-       if (!load (&ci, drv, track))
+       if (!load (&ci, drv, track, true))
                return 0;
        *multirev = (ci.type & CTIT_FLAG_FLAKEY) ? 1 : 0;
        if (oldlib) {

diff --git a/od-win32/cloanto/RetroPlatformIPC.h b/od-win32/cloanto/RetroPlatformIPC.h
index 9d54969c6b896fbddebea55d3765c28c8eafd0c9..505082765322ee60ab9ea497277207b7f014b2c6 100755 (executable)
--- a/od-win32/cloanto/RetroPlatformIPC.h
+++ b/od-win32/cloanto/RetroPlatformIPC.h
@@ -3,12 +3,12 @@
  Project : RetroPlatform Player
  Client  : Cloanto Italia srl
  Support : http://www.retroplatform.com
- Legal   : Copyright 2007-2010 Cloanto Italia srl - All rights reserved. This
+ Legal   : Copyright 2007-2011 Cloanto Italia srl - All rights reserved. This
          : file is made available under the terms of the GNU General Public
          : License version 2 as published by the Free Software Foundation.
  Authors : os, mcb
  Created : 2007-08-27 13:55:49
- Updated : 2010-08-17 19:01:00
+ Updated : 2011-02-02 12:20:00
  Comment : RP Player interprocess communication include file
  *****************************************************************************/
 
@@ -17,9 +17,9 @@
 
 #include <windows.h>
 
-#define RPLATFORM_API_VER       "1.2"
+#define RPLATFORM_API_VER       "1.4"
 #define RPLATFORM_API_VER_MAJOR  1
-#define RPLATFORM_API_VER_MINOR  2
+#define RPLATFORM_API_VER_MINOR  4
 
 #define RPIPC_HostWndClass   "RetroPlatformHost%s"
 #define RPIPC_GuestWndClass  "RetroPlatformGuest%d"
@@ -74,6 +74,7 @@
 #define RPIPCHM_LOADSTATE       (WM_APP + 214)
 #define RPIPCHM_FLUSH           (WM_APP + 215)
 #define RPIPCHM_DEVICEREADWRITE (WM_APP + 216)
+#define RPIPCHM_QUERYSCREENMODE (WM_APP + 217)
 
 // ****************************************************************************
 //  Message Data Structures and Defines
@@ -114,14 +115,39 @@
 #define RP_SCREENMODE_USETVM(m)     ((m) & RP_SCREENMODE_USETVMMASK) // given a mode 'm' returns the RP_SCREENMODE_USETVM_* value in it (automatic display mode selection in full screen modes)
 #define RP_SCREENMODE_MODE(m)       ((m) & RP_SCREENMODE_MODEMASK) // given a mode 'm' returns the #X mode
 
+// Clip Flags (used only from host to guest, never from guest to host)
+#define RP_CLIPFLAGS_AUTOCLIP          0x00000001 // ignore all 4 Clip values (same as all values = -1) and use "smart" offset and size
+#define RP_CLIPFLAGS_NOCLIP                    0x00000002 // ignore all 4 Clip values (same as all values = -1) and use 0:0 offset and maximum possible size (probably ugly, but good for adjusting clip area manually)
+
+// Clip/Scale Examples
+//
+// An Amiga game with known clip offset/size will have lClipLeft/Top/Width/Height set, and no RP_CLIPFLAGS.
+// In windowed mode, the guest (e.g. WinUAE) will take the net clipped region and apply RP_SCREENMODE_xX scaling to that.
+// In RP_SCREENMODE_FULLWINDOW mode, the net clipped region will be "soft-scaled" to the maximum possible (not necessarily an integer scaling factor), centered and padded by a black border.
+// In one of the RP_SCREENMODE_FULLSCREEN modes, the net clipped region will be centered in the smallest possible compatible hardware mode (in consideration of RP_SCREENMODE_USETVM) and padded by a black border.
+// If an Amiga application sets a different Amiga chipset screen mode, the "container" window size will remain unchanged.
+// If an Amiga application sets a different RTG screen mode, the "container" window size will reflect the new RTG size (instead of the Amiga clip size) and apply RP_SCREENMODE_xX.
+//
+// An unknown Amiga application or one that has no known clip offset/size will start with RP_CLIPFLAGS_AUTOCLIP.
+// The guest (e.g. WinUAE) will apply whatever logic it can to minimize the visible overscan region.
+// The guest will send to the host the actual RPScreenMode data with the offset/size details that were applied.
+// In windowed mode, RP_SCREENMODE_xX scaling is applied like in the previous example.
+// RP_SCREENMODE_FULLWINDOW and RP_SCREENMODE_FULLSCREEN modes behave like in the previous example (scaling, etc.)
+// If an Amiga application sets a different Amiga or RTG chipset screen mode, the "container" window size may change.
+//
+// If the user wants to adjust clipping, or for automated grabs and calculations, it is possible to set RP_CLIPFLAGS_NOCLIP, which will widen the window to the maximum.
+//
+// Whenever the guest sets or changes the "container" window size (initially, or due to a command it receives, or due to Amiga-sourced changes), it sends a RPScreenMode update to the host.
+
 typedef struct RPScreenMode
 {
        DWORD dwScreenMode; // RP_SCREENMODE_* values and flags
-       LONG lClipLeft;     // 0 = reset, -1 = ignore
-       LONG lClipTop;      // 0 = reset, -1 = ignore
-       LONG lClipWidth;    // 0 = reset, -1 = ignore
-       LONG lClipHeight;   // 0 = reset, -1 = ignore
+       LONG lClipLeft;     // -1 = ignore (0 is a valid value)
+       LONG lClipTop;      // -1 = ignore (0 is a valid value)
+       LONG lClipWidth;    // -1 = ignore
+       LONG lClipHeight;   // -1 = ignore
        HWND hGuestWindow;  // only valid for RPIPCGM_SCREENMODE
+       DWORD dwClipFlags;      
 } RPSCREENMODE;
 
 // Device Categories

diff --git a/od-win32/cloanto/RetroPlatformIPC_doc_draft.txt b/od-win32/cloanto/RetroPlatformIPC_doc_draft.txt
index 406925ae2b214cc4ae771520910b9703a3f45957..6ad30b255342e4f3d7b6d4c25cf28cc8b3f8dc65 100755 (executable)
--- a/od-win32/cloanto/RetroPlatformIPC_doc_draft.txt
+++ b/od-win32/cloanto/RetroPlatformIPC_doc_draft.txt
@@ -132,7 +132,7 @@ Description:
    unless this is an asynchronous screen mode change
    (i.e. the guest returned the INVALID_HANDLE_VALUE
    response to a RPIPCHM_SCREENMODE host request);
-   at startup-time, the guest must create
+   at startup time, the guest must create
    a borderless and hidden window and send its handle
    using this message; the host will then take care
    of preparing, positioning and showing the guest window
@@ -171,9 +171,10 @@ Message:
    RPIPCGM_DEVICEACTIVITY
 Description:
    this message can be used to turn on or off the activity indicator
-   of a specified device (like a LED on the original hardware)
-   or to notify the host about the status of a joystick;
-   the indicator can also be "blinked", i.e. the host will turn the
+   of a specified device (a single LED on the original hardware)
+   or to notify the host about the status of a joystick (multiple buttons);
+   device LED indicators (e.g. the disk activity ones, not the joystick ones)
+   can also be "blinked", i.e. the host will turn the
    LED on and then off again after the specified amount of time
 Data sent:
    WPARAM = device category (RP_DEVICE_* value) and device number
@@ -181,17 +182,19 @@ Data sent:
             e.g. MAKEWORD(RP_DEVICE_FLOPPY, 0);
             the RP_ALL_DEVICES define may be used as device number
             to turn on or off all the activity leds for a device category
-   LPARAM = led status and flags combined with the MAKELONG macro;
-            e.g. MAKELONG(Status, Flags);
+   LPARAM = for non-joystick devices, LED status and flags are combined
+            with the MAKELONG macro;e.g. MAKELONG(Status, Flags);
             the Status value can be set to 0 to turn off the activity LED,
             to -1 to turn on the activity LED,
             or to a <millisecond delay> value to turn on the activity LED
             for the specified amount of time (blink);
             the Flags value can be set
             using one or more of the RP_DEVICEACTIVITY_* defines;
-            in case the message references a RP_DEVICE_INPUTPORT device
+            if the message references a RP_DEVICE_INPUTPORT device
             connected to a joystick, the data sent via LPARAM
-            is a combination of RP_JOYSTICK_* values
+            is a mask of RP_JOYSTICK_* values (no MAKELONG macro)
+            reflecting all buttons that are pressed (some may be
+            pressed simultaneously)
 Response:
    none
 
@@ -627,3 +630,15 @@ Data sent:
    none
 Response:
    LRESULT = 1 if the guest successfully executed the command or 0 otherwise
+
+
+Message:
+   RPIPCHM_QUERYSCREENMODE
+Description:
+   this message is used to ask the guest to send
+   a RPIPCGM_SCREENMODE notification as soon as possible
+   with updated screen mode and clipping information
+Data sent:
+   none
+Response:
+   LRESULT = 1 if the guest acknowledged the command or 0 otherwise

diff --git a/od-win32/parser.cpp b/od-win32/parser.cpp
index 799efbb06af3bd626513394d26473ceb4fcf4a9e..7b5c380f822742930972129e9abdd898ce053d30 100644 (file)
--- a/od-win32/parser.cpp
+++ b/od-win32/parser.cpp
@@ -1320,9 +1320,41 @@ int enumserialports (void)
        write_log (L"Parallel port enumeration..\n");
        enumports_2 (parports, 0, true);
        write_log (L"Port enumeration end\n");
+
        return cnt;
 }
 
+int enummidiports (void)
+{
+       MIDIOUTCAPS midiOutCaps;
+       MIDIINCAPS midiInCaps;
+       int i, num, total;
+       
+       write_log (L"MIDI port enumeration..\n");
+       num = midiOutGetNumDevs ();
+       for (i = 0; i < num + 1 && i < MAX_MIDI_PORTS; i++) {
+               if (midiOutGetDevCaps (i - 1, &midiOutCaps, sizeof (midiOutCaps)) != MMSYSERR_NOERROR)
+                       break;
+               midioutportinfo[i].name = my_strdup (midiOutCaps.szPname);
+               write_log (L"MIDI OUT: '%s' (%d/%d)\n", midioutportinfo[i].name, midiOutCaps.wMid, midiOutCaps.wPid);
+       }
+       total = num;
+
+       num = midiInGetNumDevs ();
+       for (i = 0; i < num && i < MAX_MIDI_PORTS; i++) {
+               if (midiInGetDevCaps (i, &midiInCaps, sizeof (midiInCaps)) != MMSYSERR_NOERROR)
+                       break;
+               midiinportinfo[i].name = my_strdup (midiInCaps.szPname);
+               write_log (L"MIDI IN: '%s' (%d/%d)\n", midiinportinfo[i].name, midiInCaps.wMid, midiInCaps.wPid);
+       }
+       total += num;
+
+       write_log (L"MIDI port enumeration end\n");
+
+       return total;
+}
+
+
 void sernametodev (TCHAR *sername)
 {
        int i;

diff --git a/od-win32/parser.h b/od-win32/parser.h
index cc6f56b7f215a0fdd460e0da2474c13b19f7ee30..0c7454b588ffa0959092e172b8843a56ebe22483 100644 (file)
--- a/od-win32/parser.h
+++ b/od-win32/parser.h
@@ -33,6 +33,14 @@ void serialuartbreak (int);
 extern void unload_ghostscript (void);
 extern int load_ghostscript (void);
 
+#define MAX_MIDI_PORTS 16
+struct midiportinfo
+{
+    TCHAR *name;
+};
+extern struct midiportinfo midiinportinfo[MAX_MIDI_PORTS];
+extern struct midiportinfo midioutportinfo[MAX_MIDI_PORTS];
+
 #define MAX_SERPAR_PORTS 32
 struct serparportinfo
 {
@@ -44,6 +52,7 @@ extern struct serparportinfo comports[MAX_SERPAR_PORTS];
 extern struct serparportinfo parports[MAX_SERPAR_PORTS];
 
 extern int enumserialports (void);
+extern int enummidiports (void);
 extern void sernametodev (TCHAR*);
 extern void serdevtoname (TCHAR*);
 

diff --git a/od-win32/picasso96_win.cpp b/od-win32/picasso96_win.cpp
index e6c69856238370931b5a09e69783275810829eb1..8d32aad1bc230ffbbfb12691c3d397cd8a4063fc 100644 (file)
--- a/od-win32/picasso96_win.cpp
+++ b/od-win32/picasso96_win.cpp
@@ -2482,8 +2482,9 @@ static uae_u32 REGPARAM2 picasso_SetPanning (TrapContext *ctx)
 
        full_refresh = 1;
        set_panning_called = 1;
-       P96TRACE((L"SetPanning(%d, %d, %d) Start 0x%x, BPR %d Bpp %d RGBF %d\n",
+       P96TRACE((L"SetPanning(%d, %d, %d) (%dx%d) Start 0x%x, BPR %d Bpp %d RGBF %d\n",
                Width, picasso96_state.XOffset, picasso96_state.YOffset,
+               bme_width, bme_height,
                start_of_screen, picasso96_state.BytesPerRow, picasso96_state.BytesPerPixel, picasso96_state.RGBFormat));
        init_picasso_screen ();
        set_panning_called = 0;
@@ -3778,13 +3779,13 @@ static void copyrow (uae_u8 *src, uae_u8 *dst, int x, int y, int width)
        }
 }
 
-static void copyallinvert (uae_u8 *src, uae_u8 *dst)
+static void copyallinvert (uae_u8 *src, uae_u8 *dst, int pwidth, int pheight)
 {
        int x, y, w;
 
-       w = picasso96_state.Width * picasso_vidinfo.pixbytes;
+       w = pwidth * picasso_vidinfo.pixbytes;
        if (picasso96_state.RGBFormat == host_mode) {
-               for (y = 0; y < picasso96_state.Height; y++) {
+               for (y = 0; y < pheight; y++) {
                        for (x = 0; x < w; x++)
                                dst[x] = src[x] ^ 0xff;
                        dst += picasso_vidinfo.rowbytes;
@@ -3792,10 +3793,10 @@ static void copyallinvert (uae_u8 *src, uae_u8 *dst)
                }
        } else {
                uae_u8 *src2 = src;
-               for (y = 0; y < picasso96_state.Height; y++) {
+               for (y = 0; y < pheight; y++) {
                        for (x = 0; x < w; x++)
                                src2[x] ^= 0xff;
-                       copyrow (src, dst, 0, y, picasso96_state.Width);
+                       copyrow (src, dst, 0, y, pwidth);
                        for (x = 0; x < w; x++)
                                src2[x] ^= 0xff;
                        src2 += picasso96_state.BytesPerRow;
@@ -3803,22 +3804,20 @@ static void copyallinvert (uae_u8 *src, uae_u8 *dst)
        }
 }
 
-static void copyall (uae_u8 *src, uae_u8 *dst)
+static void copyall (uae_u8 *src, uae_u8 *dst, int pwidth, int pheight)
 {
        int y;
-       uae_u8 *dstb;
 
-       dstb = dst;
        if (picasso96_state.RGBFormat == host_mode) {
-               int w = picasso96_state.Width * picasso_vidinfo.pixbytes;
-               for (y = 0; y < picasso96_state.Height; y++) {
+               int w = pwidth * picasso_vidinfo.pixbytes;
+               for (y = 0; y < pheight; y++) {
                        memcpy (dst, src, w);
                        dst += picasso_vidinfo.rowbytes;
                        src += picasso96_state.BytesPerRow;
                }
        } else {
-               for (y = 0; y < picasso96_state.Height; y++)
-                       copyrow (src, dst, 0, y, picasso96_state.Width);
+               for (y = 0; y < pheight; y++)
+                       copyrow (src, dst, 0, y, pwidth);
        }
 }
 
@@ -3827,17 +3826,23 @@ static int flushpixels (void)
        int i;
        uae_u8 *src = p96ram_start + natmem_offset;
        int off = picasso96_state.XYOffset - gfxmem_start;
-       uae_u8 *src_start = src + (off & ~gwwpagemask);
-       uae_u8 *src_end = src + ((off + picasso96_state.BytesPerRow * picasso96_state.Height + gwwpagesize - 1) & ~gwwpagemask);
-       int maxy = -1;
-       int miny = picasso96_state.Height - 1;
+       uae_u8 *src_start;
+       uae_u8 *src_end;
        int lock = 0;
        uae_u8 *dst = NULL;
        ULONG_PTR gwwcnt;
+       int pwidth = picasso96_state.Width > picasso96_state.VirtualWidth ? picasso96_state.VirtualWidth : picasso96_state.Width;
+       int pheight = picasso96_state.Height > picasso96_state.VirtualHeight ? picasso96_state.VirtualHeight : picasso96_state.Height;
+       int maxy = -1;
+       int miny = pheight - 1;
+
+       src_start = src + (off & ~gwwpagemask);
+       src_end = src + ((off + picasso96_state.BytesPerRow * pheight + gwwpagesize - 1) & ~gwwpagemask);
 #if 0
-       write_log (L"%dx%d %dx%d %dx%d\n", picasso96_state.Width, picasso96_state.Width,
+       write_log (L"%dx%d %dx%d %dx%d (%dx%d)\n", picasso96_state.Width, picasso96_state.Width,
                picasso96_state.VirtualWidth, picasso96_state.VirtualHeight,
-               picasso_vidinfo.width, picasso_vidinfo.height);
+               picasso_vidinfo.width, picasso_vidinfo.height,
+               pwidth, pheight);
 #endif
        if (!picasso_vidinfo.extra_mem || !gwwbuf || src_start >= src_end)
                return 0;
@@ -3884,11 +3889,11 @@ static int flushpixels (void)
 
                if (dofull) {
                        if (flashscreen != 0)
-                               copyallinvert (src + off, dst);
+                               copyallinvert (src + off, dst, pwidth, pheight);
                        else
-                               copyall (src + off, dst);
+                               copyall (src + off, dst, pwidth, pheight);
                        miny = 0;
-                       maxy = picasso96_state.Height;
+                       maxy = pheight;
                        break;
                }
 
@@ -3905,17 +3910,17 @@ static int flushpixels (void)
                                }
 
                                y = realoffset / picasso96_state.BytesPerRow;
-                               if (y < picasso96_state.Height) {
+                               if (y < pheight) {
                                        int w = gwwpagesize / picasso96_state.BytesPerPixel;
                                        x = (realoffset % picasso96_state.BytesPerRow) / picasso96_state.BytesPerPixel;
-                                       if (x < picasso96_state.Width)
-                                               copyrow (src + off, dst, x, y, picasso96_state.Width - x);
+                                       if (x < pwidth)
+                                               copyrow (src + off, dst, x, y, pwidth - x);
                                        w = (gwwpagesize - (picasso96_state.BytesPerRow - x * picasso96_state.BytesPerPixel)) / picasso96_state.BytesPerPixel;
                                        if (y < miny)
                                                miny = y;
                                        y++;
-                                       while (y < picasso96_state.Height && w > 0) {
-                                               int maxw = w > picasso96_state.Width ? picasso96_state.Width : w;
+                                       while (y < pheight && w > 0) {
+                                               int maxw = w > pwidth ? pwidth : w;
                                                copyrow (src + off, dst, 0, y, maxw);
                                                w -= maxw;
                                                y++;
@@ -3946,7 +3951,7 @@ static int flushpixels (void)
                if (doskip () && p96skipmode == 4) {
                        ;
                } else {
-                       DX_Invalidate (0, miny, picasso96_state.Width, maxy - miny);
+                       DX_Invalidate (0, miny, pwidth, maxy - miny);
                }
        }
 

diff --git a/od-win32/rp.cpp b/od-win32/rp.cpp
index 374beed9e04523918b332203570917edd4719d2a..e85a68495ab6d282af67794781622dd82fcaae1b 100644 (file)
--- a/od-win32/rp.cpp
+++ b/od-win32/rp.cpp
@@ -118,6 +118,7 @@ static const TCHAR *getmsg (int msg)
        case RPIPCHM_LOADSTATE: return L"RPIPCHM_LOADSTATE";
        case RPIPCHM_FLUSH: return L"RPIPCHM_FLUSH";
        case RPIPCHM_DEVICEREADWRITE: return L"RPIPCHM_DEVICEREADWRITE";
+       case RPIPCHM_QUERYSCREENMODE: return L"RPIPCHM_QUERYSCREENMODE";
 
        default: return L"UNKNOWN";
        }
@@ -317,12 +318,16 @@ static void fixup_size (struct uae_prefs *prefs)
 
 static int getmult(int mult)
 {
-       if (mult <= 1)
-               return 0;
-       if (mult == 2)
-               return 1;
-       if (mult == 4)
+       if (mult >= 4 * 256)
                return 2;
+       if (mult == 2 * 256)
+               return 1;
+       if (mult >= 1 * 256)
+               return 0;
+       if (mult >= 256 / 2)
+               return -1;
+       if (mult >= 256 / 4)
+               return -2;
        return 0;
 }
 
@@ -340,7 +345,7 @@ static int shift (int val, int shift)
 #define LORES_HEIGHT 284
 static void get_screenmode (struct RPScreenMode *sm, struct uae_prefs *p)
 {
-       int m;
+       int m, cf;
        int full = 0;
        int hres, vres;
        int totalhdbl = -1, totalvdbl = -1;
@@ -348,10 +353,11 @@ static void get_screenmode (struct RPScreenMode *sm, struct uae_prefs *p)
 
        hres = p->gfx_resolution;
        vres = p->gfx_vresolution;
-       hmult = 1000 / p->gfx_filter_horiz_zoom_mult;
-       vmult = 1000 / p->gfx_filter_vert_zoom_mult;
+       hmult = p->gfx_filter_horiz_zoom_mult ? 1000 * 256 / p->gfx_filter_horiz_zoom_mult : 256;
+       vmult = p->gfx_filter_vert_zoom_mult ? 1000 * 256 / p->gfx_filter_vert_zoom_mult : 256;
 
        m = RP_SCREENMODE_1X;
+       cf = 0;
 
        if (WIN32GFX_IsPicassoScreen ()) {
 
@@ -407,6 +413,11 @@ static void get_screenmode (struct RPScreenMode *sm, struct uae_prefs *p)
                        m = RP_SCREENMODE_XX;
                if (p->gfx_filter_scanlines || p->gfx_scanlines)
                        m |= RP_SCREENMODE_SCANLINES;
+
+               if (p->gfx_xcenter_pos == 0 && p->gfx_ycenter_pos == 0)
+                       cf |= RP_CLIPFLAGS_NOCLIP;
+               else if (p->gfx_filter_autoscale == AUTOSCALE_RESIZE || p->gfx_filter_autoscale == AUTOSCALE_NORMAL)
+                       cf |= RP_CLIPFLAGS_AUTOCLIP;
        }
        if (full) {
                m &= ~0x0000ff00;
@@ -414,7 +425,9 @@ static void get_screenmode (struct RPScreenMode *sm, struct uae_prefs *p)
        }
        if (full > 1)
                m |= RP_SCREENMODE_FULLWINDOW;
+
        sm->dwScreenMode = m;
+       sm->dwClipFlags = cf;
 
        if (log_rp)
                write_log (L"GET_RPSM: %08X %dx%d %dx%d hres=%d (%d) vres=%d (%d) disp=%d fs=%d\n",
@@ -533,19 +546,34 @@ static void set_screenmode (struct RPScreenMode *sm, struct uae_prefs *p)
                p->gfx_filter_keep_aspect = 0;
        }
 #endif
-       write_log(L"%dx%d %dx%d\n", sm->lClipLeft, sm->lClipTop, sm->lClipWidth, sm->lClipHeight);
-#if 1
+       write_log(L"%dx%d %dx%d %08x\n", sm->lClipLeft, sm->lClipTop, sm->lClipWidth, sm->lClipHeight, sm->dwClipFlags);
+
        p->gfx_xcenter_pos = sm->lClipLeft;
        p->gfx_ycenter_pos = sm->lClipTop;
        if (sm->lClipWidth > 0)
                p->gfx_xcenter_size = sm->lClipWidth;
        if (sm->lClipHeight > 0)
                p->gfx_ycenter_size = sm->lClipHeight;
-       if (p->gfx_xcenter_pos >= 0 || p->gfx_ycenter_pos >= 0)
+
+       if (sm->dwClipFlags & RP_CLIPFLAGS_AUTOCLIP) {
+               if (!fs)
+                       p->gfx_filter_autoscale = AUTOSCALE_RESIZE;
+               else
+                       p->gfx_filter_autoscale = AUTOSCALE_NORMAL;
+               p->gfx_xcenter_pos = -1;
+               p->gfx_ycenter_pos = -1;
+               p->gfx_xcenter_size = -1;
+               p->gfx_ycenter_size = -1;
+       } else if (sm->dwClipFlags & RP_CLIPFLAGS_NOCLIP) {
+               p->gfx_xcenter_pos = 0;
+               p->gfx_ycenter_pos = 0;
+               p->gfx_xcenter_size = 1408;
+               p->gfx_ycenter_size = 568;
+       } else if (p->gfx_xcenter_pos >= 0 || p->gfx_ycenter_pos >= 0) {
                p->gfx_filter_autoscale = AUTOSCALE_MANUAL;
-       else
+       } else {
                p->gfx_filter_autoscale = AUTOSCALE_STATIC_NOMINAL;
-#endif
+       }
 
        //p->gfx_filter = rp_filter_default;
        p->gfx_filter_horiz_zoom_mult = 1000 / hmult;
@@ -561,10 +589,13 @@ static void set_screenmode (struct RPScreenMode *sm, struct uae_prefs *p)
        }
 
        if (log_rp)
-               write_log (L"WW=%d WH=%d FW=%d FH=%d HM=%d VM=%d\n",
+               write_log (L"WW=%d WH=%d FW=%d FH=%d HM=%d VM=%d XP=%d YP=%d XS=%d YS=%d AS=%d\n",
                        p->gfx_size_win.width, p->gfx_size_win.height,
                        p->gfx_size_fs.width, p->gfx_size_fs.height,
-                       p->gfx_filter_horiz_zoom_mult, p->gfx_filter_vert_zoom_mult);
+                       p->gfx_filter_horiz_zoom_mult, p->gfx_filter_vert_zoom_mult,
+                       p->gfx_xcenter_pos, p->gfx_ycenter_pos,
+                       p->gfx_xcenter_size, p->gfx_ycenter_size,
+                       p->gfx_filter_autoscale);
 
 
        updatewinfsmode (p);
@@ -727,6 +758,15 @@ static LRESULT CALLBACK RPHostMsgFunction2 (UINT uMessage, WPARAM wParam, LPARAM
                        }
                        return ret ? (LPARAM)1 : 0;
                }
+       case RPIPCHM_FLUSH:
+               return 1;
+       case RPIPCHM_QUERYSCREENMODE:
+               {
+                       struct RPScreenMode sm = { 0 };
+                       get_screenmode (&sm, &currprefs);
+                       RPSendMessagex (RPIPCGM_SCREENMODE, 0, 0, &sm, sizeof sm, &guestinfo, NULL);
+                       return 1;
+               }
        }
        return FALSE;
 }
@@ -756,6 +796,7 @@ HRESULT rp_init (void)
 {
        HRESULT hr;
 
+       write_log (L"rp_init()\n");
        hr = RPInitializeGuest (&guestinfo, hInst, rp_param, RPHostMsgFunction, 0);
        if (SUCCEEDED (hr)) {
                initialized = TRUE;
@@ -1032,13 +1073,20 @@ void rp_cd_device_enable (int num, bool enabled)
 
 void rp_floppy_track (int floppy, int track)
 {
+       static int oldtrack[4];
        if (!cando ())
                return;
+       if (oldtrack[floppy] == track)
+               return;
+       oldtrack[floppy] = track;
        RPPostMessagex (RPIPCGM_DEVICESEEK, MAKEWORD (RP_DEVICE_FLOPPY, floppy), track, &guestinfo);
 }
 
 void rp_update_leds (int led, int onoff, int write)
 {
+       static int oldled[5];
+       int ledstate;
+
        if (!cando ())
                return;
        if (led < 0 || led > 4)
@@ -1046,14 +1094,23 @@ void rp_update_leds (int led, int onoff, int write)
        switch (led)
        {
        case 0:
-               RPSendMessage (RPIPCGM_POWERLED, onoff >= 250 ? 100 : onoff * 10 / 26, 0, NULL, 0, &guestinfo, NULL);
+               ledstate = onoff >= 250 ? 100 : onoff * 10 / 26;
+               if (ledstate == oldled[led])
+                       return;
+               oldled[led] = ledstate;
+               RPSendMessage (RPIPCGM_POWERLED, ledstate, 0, NULL, 0, &guestinfo, NULL);
                break;
        case 1:
        case 2:
        case 3:
        case 4:
+               ledstate = onoff ? 1 : 0;
+               ledstate |= write ? 2 : 0;
+               if (ledstate == oldled[led])
+                       return;
+               oldled[led] = ledstate;
                RPPostMessagex (RPIPCGM_DEVICEACTIVITY, MAKEWORD (RP_DEVICE_FLOPPY, led - 1),
-                       MAKELONG (onoff ? -1 : 0, write ? RP_DEVICEACTIVITY_WRITE : RP_DEVICEACTIVITY_READ) , &guestinfo);
+                       MAKELONG ((ledstate & 1) ? -1 : 0, (ledstate & 2) ? RP_DEVICEACTIVITY_WRITE : RP_DEVICEACTIVITY_READ) , &guestinfo);
                break;
        }
 }
@@ -1071,20 +1128,30 @@ void rp_update_gameport (int port, int mask, int onoff)
                gameportmask[port] |= mask;
        else
                gameportmask[port] &= ~mask;
-       if (old != gameportmask[port])
+       if (old != gameportmask[port]) {
                RPPostMessagex (RPIPCGM_DEVICEACTIVITY, MAKEWORD (RP_DEVICE_INPUTPORT, port),
                        gameportmask[port], &guestinfo);
+       }
 }
 
 void rp_hd_activity (int num, int onoff, int write)
 {
+       static int oldleds[MAX_TOTAL_SCSI_DEVICES];
+       static int state;
+
        if (!cando ())
                return;
        if (num < 0)
                return;
-       if (onoff)
+       state = onoff ? 1 : 0;
+       state |= write ? 2 : 0;
+       if (state == oldleds[num])
+               return;
+       oldleds[num] = state;
+       if (state & 1) {
                RPPostMessagex (RPIPCGM_DEVICEACTIVITY, MAKEWORD (RP_DEVICE_HD, num),
-               MAKELONG (200, write ? RP_DEVICEACTIVITY_WRITE : RP_DEVICEACTIVITY_READ), &guestinfo);
+                       MAKELONG (200, (state & 2) ? RP_DEVICEACTIVITY_WRITE : RP_DEVICEACTIVITY_READ), &guestinfo);
+       }
 }
 
 void rp_cd_activity (int num, int onoff)

diff --git a/od-win32/win32.cpp b/od-win32/win32.cpp
index 6813bfe23404a7690da322bdbbf8e6f3a130c25d..d9dab98291c4f16ea6920004419c3ee8d3a45ba8 100644 (file)
--- a/od-win32/win32.cpp
+++ b/od-win32/win32.cpp
@@ -94,7 +94,9 @@
 extern int harddrive_dangerous, do_rdbdump, aspi_allow_all, no_rawinput;
 extern int force_directsound;
 extern int log_a2065, a2065_promiscuous;
-int log_scsi, log_net, uaelib_debug;
+int log_scsi;
+int log_net;
+int uaelib_debug;
 int pissoff_value = 25000;
 unsigned int fpucontrol;
 
@@ -802,11 +804,11 @@ void gui_gameport_axis_change (int port, int axis, int state, int max)
                if (axis == DIR_LEFT_BIT)
                        rp_update_gameport (port, RP_JOYSTICK_LEFT, onoff);
                if (axis == DIR_RIGHT_BIT)
-                       rp_update_gameport (port, DIR_RIGHT_BIT, onoff);
+                       rp_update_gameport (port, RP_JOYSTICK_RIGHT, onoff);
                if (axis == DIR_UP_BIT)
-                       rp_update_gameport (port, DIR_UP_BIT, onoff);
+                       rp_update_gameport (port, RP_JOYSTICK_UP, onoff);
                if (axis == DIR_DOWN_BIT)
-                       rp_update_gameport (port, DIR_DOWN_BIT, onoff);
+                       rp_update_gameport (port, RP_JOYSTICK_DOWN, onoff);
 #endif
        }
        guijoychange = true;
@@ -2799,8 +2801,28 @@ void target_save_options (struct zfile *f, struct uae_prefs *p)
        cfgfile_target_dwrite_bool (f, L"inactive_iconify", p->win32_minimize_inactive);
 
        cfgfile_target_dwrite_bool (f, L"ctrl_f11_is_quit", p->win32_ctrl_F11_is_quit);
+
        cfgfile_target_dwrite (f, L"midiout_device", L"%d", p->win32_midioutdev);
        cfgfile_target_dwrite (f, L"midiin_device", L"%d", p->win32_midiindev);
+       if (p->win32_midioutdev < -1)
+               cfgfile_target_dwrite_str (f, L"midiout_device_name", L"none");
+       else if (p->win32_midioutdev == -1)
+               cfgfile_target_dwrite_str (f, L"midiout_device_name", L"default");
+       else if (p->win32_midioutdev >= 0 && p->win32_midioutdev < MAX_MIDI_PORTS) {
+               if (midioutportinfo[p->win32_midioutdev + 1].name == NULL)
+                       p->win32_midioutdev = -1;
+               else
+                       cfgfile_target_dwrite_str (f, L"midiout_device_name", midioutportinfo[p->win32_midioutdev + 1].name);
+       }
+       if (p->win32_midiindev < 0)
+               cfgfile_target_dwrite_str (f, L"midiin_device_name", L"none");
+       else if (p->win32_midiindev >= 0 && p->win32_midiindev < MAX_MIDI_PORTS) {
+               if (midiinportinfo[p->win32_midiindev].name == NULL)
+                       p->win32_midiindev = -1;
+               else
+                       cfgfile_target_dwrite_str (f, L"midiin_device_name", midiinportinfo[p->win32_midiindev].name);
+       }
+                       
        cfgfile_target_dwrite_bool (f, L"rtg_match_depth", p->win32_rtgmatchdepth);
        cfgfile_target_dwrite_bool (f, L"rtg_scale_small", p->win32_rtgscaleifsmall);
        cfgfile_target_dwrite_bool (f, L"rtg_scale_allow", p->win32_rtgallowscaling);
@@ -3051,6 +3073,28 @@ int target_parse_option (struct uae_prefs *p, const TCHAR *option, const TCHAR *
                return 1;
        }
 
+       if (cfgfile_string (option, value, L"midiout_device_name", tmpbuf, 256)) {
+               p->win32_midioutdev = -2;
+               if (!_tcsicmp (tmpbuf, L"default") || (midioutportinfo[0].name && !_tcsicmp (tmpbuf, midioutportinfo[0].name)))
+                       p->win32_midioutdev = -1;
+               for (int i = 0; midioutportinfo[i].name; i++) {
+                       if (!_tcsicmp (midioutportinfo[i].name, tmpbuf)) {
+                               p->win32_midioutdev = i - 1;
+                       }
+               }
+               return 1;
+       }
+       if (cfgfile_string (option, value, L"midiin_device_name", tmpbuf, 256)) {
+               p->win32_midiindev = -1;
+               for (int i = 0; midiinportinfo[i].name; i++) {
+                       if (!_tcsicmp (midiinportinfo[i].name, tmpbuf)) {
+                               p->win32_midiindev = i;
+                       }
+               }
+               return 1;
+       }
+
+
        i = 0;
        while (obsolete[i]) {
                if (!strcasecmp (obsolete[i], option)) {
@@ -4895,6 +4939,7 @@ static int PASCAL WinMain2 (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR
                        globalipc = createIPC (L"WinUAE", 0);
                        serialipc = createIPC (COMPIPENAME, 1);
                        enumserialports ();
+                       enummidiports ();
                        real_main (argc, argv);
                }
        }

diff --git a/od-win32/win32.h b/od-win32/win32.h
index b016fdb575d8a3c8b0f3f5ae6087b97fb88f4690..020569efa4178e47881d5adaf426b4005b3a98c8 100644 (file)
--- a/od-win32/win32.h
+++ b/od-win32/win32.h
@@ -18,8 +18,8 @@
 #define WINUAEPUBLICBETA 1
 #define LANG_DLL 1
 
-#define WINUAEBETA L"11"
-#define WINUAEDATE MAKEBD(2011, 1, 15)
+#define WINUAEBETA L"12"
+#define WINUAEDATE MAKEBD(2011, 2, 17)
 #define WINUAEEXTRA L""
 #define WINUAEREV L""
 

diff --git a/od-win32/win32_scaler.cpp b/od-win32/win32_scaler.cpp
index 5ca52d38ea2ab4591cf0aac1a0427be9f70f94c7..67f3e29c6ff8feb8040468f5418f8f15b5e520b0 100644 (file)
--- a/od-win32/win32_scaler.cpp
+++ b/od-win32/win32_scaler.cpp
@@ -222,7 +222,7 @@ void getfilterrect2 (RECT *sr, RECT *dr, RECT *zr, int dst_width, int dst_height
                        int w1 = (800 / 2) << currprefs.gfx_resolution;
                        int w2 = (640 / 2) << currprefs.gfx_resolution;
                        int h1 = (600 / 2) << currprefs.gfx_vresolution;
-                       int h2 = (480 / 2) << currprefs.gfx_vresolution;
+                       int h2 = (400 / 2) << currprefs.gfx_vresolution;
                        int w = currprefs.gfx_size_win.width;
                        int h = currprefs.gfx_size_win.height;
                        if (w <= w1 && h <= h1 && w >= w2 && h >= h2)
@@ -259,12 +259,12 @@ void getfilterrect2 (RECT *sr, RECT *dr, RECT *zr, int dst_width, int dst_height
                        filter_horiz_offset = 0;
                        filter_vert_offset = 0;
 
-                       get_custom_topedge(&cx, &cy);
+                       get_custom_topedge (&cx, &cy);
                        //write_log (L"%dx%d %dx%d\n", cx, cy, currprefs.gfx_resolution, currprefs.gfx_vresolution);
 
                        v = currprefs.gfx_xcenter_pos;
                        if (v >= 0)
-                               cx = (v >> (RES_MAX - currprefs.gfx_resolution + 1)) - cx;
+                               cx = (v >> (RES_MAX - currprefs.gfx_resolution)) - cx;
 
                        v = currprefs.gfx_ycenter_pos;
                        if (v >= 0)
@@ -294,6 +294,13 @@ void getfilterrect2 (RECT *sr, RECT *dr, RECT *zr, int dst_width, int dst_height
 
                }
 
+               if (currprefs.gfx_api == 0) {
+                       if (cx < 0)
+                               cx = 0;
+                       if (cy < 0)
+                               cy = 0;
+               }
+
                if (cv) {
                        int diff;
 
@@ -337,7 +344,7 @@ void getfilterrect2 (RECT *sr, RECT *dr, RECT *zr, int dst_width, int dst_height
                                lch = ch;
                                lcx = cx;
                                lcy = cy;
-                               if (useold) {
+                               if (useold && !config_changed) {
                                        cw = ocw;
                                        ch = och;
                                        cx = ocx;
@@ -350,14 +357,20 @@ void getfilterrect2 (RECT *sr, RECT *dr, RECT *zr, int dst_width, int dst_height
                                        lastresize = 10;
                                        lastdelay = 0;
                                }
-                               SetRect (sr, 0, 0, cw * scale, ch * scale);
+                               double scalex = currprefs.gfx_filter_horiz_zoom_mult ? 1000.0 / currprefs.gfx_filter_horiz_zoom_mult : 1.0;
+                               double scaley = currprefs.gfx_filter_vert_zoom_mult ? 1000.0 / currprefs.gfx_filter_vert_zoom_mult : 1.0;
+                               SetRect (sr, 0, 0, cw * scale * scalex, ch * scale * scaley);
                                dr->left = (temp_width - aws) /2;
                                dr->top = (temp_height - ahs) / 2;
                                dr->right = dr->left + cw * scale;
                                dr->bottom = dr->top + ch * scale;
                                OffsetRect (zr, cx * scale, cy * scale);
-                               int ww = dr->right - dr->left;
-                               int hh = dr->bottom - dr->top;
+                               int ww = (dr->right - dr->left) * scalex;
+                               int hh = (dr->bottom - dr->top) * scaley;
+                               if (currprefs.gfx_xcenter_size >= 0)
+                                       ww = currprefs.gfx_xcenter_size;
+                               if (currprefs.gfx_ycenter_size >= 0)
+                                       hh = currprefs.gfx_ycenter_size;
                                int oldwinw = currprefs.gfx_size_win.width;
                                int oldwinh = currprefs.gfx_size_win.width;
                                changed_prefs.gfx_size_win.width = ww;

diff --git a/od-win32/win32gui.cpp b/od-win32/win32gui.cpp
index 4886f3c5ed680eb3c0d1f4dc8c0fa0469da8de28..626066cdd4f7d1264cdf0623dfa339ce90e6c161 100644 (file)
--- a/od-win32/win32gui.cpp
+++ b/od-win32/win32gui.cpp
@@ -10338,6 +10338,8 @@ static PRINTER_INFO_1 *pInfo = NULL;
 static DWORD dwEnumeratedPrinters = 0;
 #define MAX_PRINTERS 10
 struct serparportinfo comports[MAX_SERPAR_PORTS];
+struct midiportinfo midiinportinfo[MAX_MIDI_PORTS];
+struct midiportinfo midioutportinfo[MAX_MIDI_PORTS];
 static int ghostscript_available;
 
 static int joyxprevious[4];
@@ -10616,13 +10618,11 @@ static void values_from_portsdlg (HWND hDlg)
 #endif
        }
 
-       workprefs.win32_midioutdev = SendDlgItemMessage (hDlg, IDC_MIDIOUTLIST, CB_GETCURSEL, 0, 0);
-       workprefs.win32_midioutdev -= 2;
-
-       if (bNoMidiIn) {
+       workprefs.win32_midioutdev = SendDlgItemMessage (hDlg, IDC_MIDIOUTLIST, CB_GETCURSEL, 0, 0) - 2;
+       if (bNoMidiIn || workprefs.win32_midioutdev < -1) {
                workprefs.win32_midiindev = -1;
        } else {
-               workprefs.win32_midiindev = SendDlgItemMessage (hDlg, IDC_MIDIINLIST, CB_GETCURSEL, 0, 0);
+               workprefs.win32_midiindev = SendDlgItemMessage (hDlg, IDC_MIDIINLIST, CB_GETCURSEL, 0, 0) - 1;
        }
        ew (hDlg, IDC_MIDIINLIST, workprefs.win32_midioutdev < -1 ? FALSE : TRUE);
 
@@ -10704,8 +10704,8 @@ static void values_to_portsdlg (HWND hDlg)
 
        SendDlgItemMessage (hDlg, IDC_PRINTERLIST, CB_SETCURSEL, result, 0);
        SendDlgItemMessage (hDlg, IDC_MIDIOUTLIST, CB_SETCURSEL, workprefs.win32_midioutdev + 2, 0);
-       if (!bNoMidiIn && workprefs.win32_midiindev >= 0)
-               SendDlgItemMessage (hDlg, IDC_MIDIINLIST, CB_SETCURSEL, workprefs.win32_midiindev, 0);
+       if (workprefs.win32_midiindev >= 0)
+               SendDlgItemMessage (hDlg, IDC_MIDIINLIST, CB_SETCURSEL, workprefs.win32_midiindev + 1, 0);
        else
                SendDlgItemMessage (hDlg, IDC_MIDIINLIST, CB_SETCURSEL, 0, 0);
        ew (hDlg, IDC_MIDIINLIST, workprefs.win32_midioutdev < -1 ? FALSE : TRUE);
@@ -10748,9 +10748,7 @@ static void values_to_portsdlg (HWND hDlg)
 static void init_portsdlg (HWND hDlg)
 {
        static int first;
-       int port, numdevs;
-       MIDIOUTCAPS midiOutCaps;
-       MIDIINCAPS midiInCaps;
+       int port;
        TCHAR tmp[MAX_DPATH];
 
        if (!first) {
@@ -10847,30 +10845,19 @@ static void init_portsdlg (HWND hDlg)
 
        SendDlgItemMessage (hDlg, IDC_MIDIOUTLIST, CB_RESETCONTENT, 0, 0L);
        SendDlgItemMessage (hDlg, IDC_MIDIOUTLIST, CB_ADDSTRING, 0, (LPARAM)szNone.c_str());
-       if ((numdevs = midiOutGetNumDevs ()) == 0) {
-               ew (hDlg, IDC_MIDIOUTLIST, FALSE);
-       } else {
-               TCHAR szMidiOut[MAX_DPATH];
-               WIN32GUI_LoadUIString (IDS_DEFAULTMIDIOUT, szMidiOut, MAX_DPATH);
-               SendDlgItemMessage (hDlg, IDC_MIDIOUTLIST, CB_ADDSTRING, 0, (LPARAM)szMidiOut);
-
-               for(port = 0; port < numdevs; port++) {
-                       if (midiOutGetDevCaps (port, &midiOutCaps, sizeof (midiOutCaps)) == MMSYSERR_NOERROR)
-                               SendDlgItemMessage (hDlg, IDC_MIDIOUTLIST, CB_ADDSTRING, 0, (LPARAM)midiOutCaps.szPname);
-               }
-               ew (hDlg, IDC_MIDIOUTLIST, TRUE);
+       for (port = 0; midioutportinfo[port].name; port++) {
+               SendDlgItemMessage (hDlg, IDC_MIDIOUTLIST, CB_ADDSTRING, 0, (LPARAM)midioutportinfo[port].name);
        }
+       ew (hDlg, IDC_MIDIOUTLIST, port > 0);
 
        SendDlgItemMessage (hDlg, IDC_MIDIINLIST, CB_RESETCONTENT, 0, 0L);
-       if ((numdevs = midiInGetNumDevs ()) == 0) {
-               ew (hDlg, IDC_MIDIINLIST, FALSE);
-               bNoMidiIn = TRUE;
-       } else {
-               for(port = 0; port < numdevs; port++) {
-                       if (midiInGetDevCaps (port, &midiInCaps, sizeof (midiInCaps)) == MMSYSERR_NOERROR)
-                               SendDlgItemMessage (hDlg, IDC_MIDIINLIST, CB_ADDSTRING, 0, (LPARAM)midiInCaps.szPname);
-               }
+       SendDlgItemMessage (hDlg, IDC_MIDIINLIST, CB_ADDSTRING, 0, (LPARAM)szNone.c_str());
+       for (port = 0; midiinportinfo[port].name; port++) {
+               SendDlgItemMessage (hDlg, IDC_MIDIINLIST, CB_ADDSTRING, 0, (LPARAM)midiinportinfo[port].name);
        }
+       bNoMidiIn = port == 0;
+       ew (hDlg, IDC_MIDIINLIST, port > 0);
+
 }
 
 static void input_test (HWND hDlg, int);
@@ -12018,7 +12005,7 @@ static void enable_for_hw3ddlg (HWND hDlg)
 {
        int v = workprefs.gfx_filter ? TRUE : FALSE;
        int vv = FALSE, vv2 = FALSE, vv3 = FALSE;
-       int as = workprefs.gfx_filter_autoscale == AUTOSCALE_CENTER;
+       int as = FALSE;
        struct uae_filter *uf;
        int i, isfilter;
 
@@ -12220,13 +12207,16 @@ static void values_to_hw3ddlg (HWND hDlg)
        SendDlgItemMessage (hDlg, IDC_FILTERAUTOSCALE, CB_ADDSTRING, 0, (LPARAM)txt);
        SendDlgItemMessage (hDlg, IDC_FILTERAUTOSCALE, CB_SETCURSEL, workprefs.gfx_filter_autoscale, 0);
 
-       SendDlgItemMessage (hDlg, IDC_FILTERHZ, TBM_SETRANGE, TRUE, MAKELONG (-999, +999));
+       int range1 = workprefs.gfx_filter_autoscale == AUTOSCALE_MANUAL ? -1 : -999;
+       int range2 = workprefs.gfx_filter_autoscale == AUTOSCALE_MANUAL ? 1800 : 999;
+
+       SendDlgItemMessage (hDlg, IDC_FILTERHZ, TBM_SETRANGE, TRUE, MAKELONG (range1, range2));
        SendDlgItemMessage (hDlg, IDC_FILTERHZ, TBM_SETPAGESIZE, 0, 1);
-       SendDlgItemMessage (hDlg, IDC_FILTERVZ, TBM_SETRANGE, TRUE, MAKELONG (-999, +999));
+       SendDlgItemMessage (hDlg, IDC_FILTERVZ, TBM_SETRANGE, TRUE, MAKELONG (range1, range2));
        SendDlgItemMessage (hDlg, IDC_FILTERVZ, TBM_SETPAGESIZE, 0, 1);
-       SendDlgItemMessage (hDlg, IDC_FILTERHO, TBM_SETRANGE, TRUE, MAKELONG (-999, +999));
+       SendDlgItemMessage (hDlg, IDC_FILTERHO, TBM_SETRANGE, TRUE, MAKELONG (range1, range2));
        SendDlgItemMessage (hDlg, IDC_FILTERHO, TBM_SETPAGESIZE, 0, 1);
-       SendDlgItemMessage (hDlg, IDC_FILTERVO, TBM_SETRANGE, TRUE, MAKELONG (-999, +999));
+       SendDlgItemMessage (hDlg, IDC_FILTERVO, TBM_SETRANGE, TRUE, MAKELONG (range1, range2));
        SendDlgItemMessage (hDlg, IDC_FILTERVO, TBM_SETPAGESIZE, 0, 1);
 
        SendDlgItemMessage (hDlg, IDC_FILTEROVERLAY, CB_RESETCONTENT, 0, 0L);
@@ -12402,21 +12392,25 @@ static void values_to_hw3ddlg (HWND hDlg)
                SendDlgItemMessage (hDlg, IDC_FILTERPRESETS, CB_SETCURSEL, filterpreset_selected, 0);
                regclosetree (fkey);
        }
-       int ho, vo;
+       int ho, vo, hz, vz;
        if (workprefs.gfx_filter_autoscale == AUTOSCALE_MANUAL) {
+               hz = workprefs.gfx_xcenter_size;
+               vz = workprefs.gfx_ycenter_size;
                ho = workprefs.gfx_xcenter_pos;
                vo = workprefs.gfx_ycenter_pos;
        } else {
+               hz = workprefs.gfx_filter_horiz_zoom;
+               vz = workprefs.gfx_filter_vert_zoom;
                ho = workprefs.gfx_filter_horiz_offset;
                vo = workprefs.gfx_filter_vert_offset;
        }
 
-       SendDlgItemMessage (hDlg, IDC_FILTERHZ, TBM_SETPOS, TRUE, workprefs.gfx_filter_horiz_zoom);
-       SendDlgItemMessage (hDlg, IDC_FILTERVZ, TBM_SETPOS, TRUE, workprefs.gfx_filter_vert_zoom);
+       SendDlgItemMessage (hDlg, IDC_FILTERHZ, TBM_SETPOS, TRUE, hz);
+       SendDlgItemMessage (hDlg, IDC_FILTERVZ, TBM_SETPOS, TRUE, vz);
        SendDlgItemMessage (hDlg, IDC_FILTERHO, TBM_SETPOS, TRUE, ho);
        SendDlgItemMessage (hDlg, IDC_FILTERVO, TBM_SETPOS, TRUE, vo);
-       SetDlgItemInt (hDlg, IDC_FILTERHZV, workprefs.gfx_filter_horiz_zoom, TRUE);
-       SetDlgItemInt (hDlg, IDC_FILTERVZV, workprefs.gfx_filter_vert_zoom, TRUE);
+       SetDlgItemInt (hDlg, IDC_FILTERHZV, hz, TRUE);
+       SetDlgItemInt (hDlg, IDC_FILTERVZV, vo, TRUE);
        SetDlgItemInt (hDlg, IDC_FILTERHOV, ho, TRUE);
        SetDlgItemInt (hDlg, IDC_FILTERVOV, vo, TRUE);
 }
@@ -12764,30 +12758,35 @@ static INT_PTR CALLBACK hw3dDlgProc (HWND hDlg, UINT msg, WPARAM wParam, LPARAM
                        if (recursive)
                                break;
                        recursive++;
-                       if (h == hz) {
-                               currprefs.gfx_filter_horiz_zoom = workprefs.gfx_filter_horiz_zoom = (int)SendMessage (hz, TBM_GETPOS, 0, 0);
-                               if (workprefs.gfx_filter_keep_aspect) {
-                                       currprefs.gfx_filter_vert_zoom = workprefs.gfx_filter_vert_zoom = currprefs.gfx_filter_horiz_zoom;
-                                       SendDlgItemMessage (hDlg, IDC_FILTERVZ, TBM_SETPOS, TRUE, workprefs.gfx_filter_vert_zoom);
-                               }
-                       } else if (h == vz) {
-                               currprefs.gfx_filter_vert_zoom = workprefs.gfx_filter_vert_zoom = (int)SendMessage (vz, TBM_GETPOS, 0, 0);
-                               if (workprefs.gfx_filter_keep_aspect) {
-                                       currprefs.gfx_filter_horiz_zoom = workprefs.gfx_filter_horiz_zoom = currprefs.gfx_filter_vert_zoom;
-                                       SendDlgItemMessage (hDlg, IDC_FILTERHZ, TBM_SETPOS, TRUE, workprefs.gfx_filter_horiz_zoom);
-                               }
+                       if (currprefs.gfx_filter_autoscale == AUTOSCALE_MANUAL) {
+                               currprefs.gfx_xcenter_size = workprefs.gfx_xcenter_size = (int)SendMessage (hz, TBM_GETPOS, 0, 0);
+                               currprefs.gfx_ycenter_size = workprefs.gfx_ycenter_size = (int)SendMessage (vz, TBM_GETPOS, 0, 0);
+                               currprefs.gfx_xcenter_pos = workprefs.gfx_xcenter_pos = (int)SendMessage (GetDlgItem (hDlg, IDC_FILTERHO), TBM_GETPOS, 0, 0);
+                               currprefs.gfx_ycenter_pos = workprefs.gfx_ycenter_pos = (int)SendMessage (GetDlgItem (hDlg, IDC_FILTERVO), TBM_GETPOS, 0, 0);
+                               SetDlgItemInt (hDlg, IDC_FILTERHOV, workprefs.gfx_xcenter_pos, TRUE);
+                               SetDlgItemInt (hDlg, IDC_FILTERVOV, workprefs.gfx_ycenter_pos, TRUE);
+                               SetDlgItemInt (hDlg, IDC_FILTERHZV, workprefs.gfx_xcenter_size, TRUE);
+                               SetDlgItemInt (hDlg, IDC_FILTERVZV, workprefs.gfx_ycenter_size, TRUE);
                        } else {
-                               if (currprefs.gfx_filter_autoscale == AUTOSCALE_MANUAL) {
-                                       currprefs.gfx_xcenter_pos = workprefs.gfx_xcenter_pos = (int)SendMessage (GetDlgItem (hDlg, IDC_FILTERHO), TBM_GETPOS, 0, 0);
-                                       currprefs.gfx_ycenter_pos = workprefs.gfx_ycenter_pos = (int)SendMessage (GetDlgItem (hDlg, IDC_FILTERVO), TBM_GETPOS, 0, 0);
-                                       SetDlgItemInt (hDlg, IDC_FILTERHOV, workprefs.gfx_xcenter_pos, TRUE);
-                                       SetDlgItemInt (hDlg, IDC_FILTERVOV, workprefs.gfx_ycenter_pos, TRUE);
-                               } else {
-                                       currprefs.gfx_filter_horiz_offset = workprefs.gfx_filter_horiz_offset = (int)SendMessage (GetDlgItem (hDlg, IDC_FILTERHO), TBM_GETPOS, 0, 0);
+                               if (h == hz) {
+                                       currprefs.gfx_filter_horiz_zoom = workprefs.gfx_filter_horiz_zoom = (int)SendMessage (hz, TBM_GETPOS, 0, 0);
+                                       if (workprefs.gfx_filter_keep_aspect) {
+                                               currprefs.gfx_filter_vert_zoom = workprefs.gfx_filter_vert_zoom = currprefs.gfx_filter_horiz_zoom;
+                                               SendDlgItemMessage (hDlg, IDC_FILTERVZ, TBM_SETPOS, TRUE, workprefs.gfx_filter_vert_zoom);
+                                       }
+                               } else if (h == vz) {
+                                       currprefs.gfx_filter_vert_zoom = workprefs.gfx_filter_vert_zoom = (int)SendMessage (vz, TBM_GETPOS, 0, 0);
+                                       if (workprefs.gfx_filter_keep_aspect) {
+                                               currprefs.gfx_filter_horiz_zoom = workprefs.gfx_filter_horiz_zoom = currprefs.gfx_filter_vert_zoom;
+                                               SendDlgItemMessage (hDlg, IDC_FILTERHZ, TBM_SETPOS, TRUE, workprefs.gfx_filter_horiz_zoom);
+                                       }
+                               }
+                               currprefs.gfx_filter_horiz_offset = workprefs.gfx_filter_horiz_offset = (int)SendMessage (GetDlgItem (hDlg, IDC_FILTERHO), TBM_GETPOS, 0, 0);
                                        currprefs.gfx_filter_vert_offset = workprefs.gfx_filter_vert_offset = (int)SendMessage (GetDlgItem (hDlg, IDC_FILTERVO), TBM_GETPOS, 0, 0);
                                        SetDlgItemInt (hDlg, IDC_FILTERHOV, workprefs.gfx_filter_horiz_offset, TRUE);
                                        SetDlgItemInt (hDlg, IDC_FILTERVOV, workprefs.gfx_filter_vert_offset, TRUE);
-                               }
+                               SetDlgItemInt (hDlg, IDC_FILTERHZV, workprefs.gfx_filter_horiz_zoom, TRUE);
+                               SetDlgItemInt (hDlg, IDC_FILTERVZV, workprefs.gfx_filter_vert_zoom, TRUE);
                        }
                        if (filter_selected) {
                                int *pw = filter_selected->varw;
@@ -12801,8 +12800,6 @@ static INT_PTR CALLBACK hw3dDlgProc (HWND hDlg, UINT msg, WPARAM wParam, LPARAM
                                *pc = v;
                                SetDlgItemInt (hDlg, IDC_FILTERXLV, v, TRUE);
                        }
-                       SetDlgItemInt (hDlg, IDC_FILTERHZV, workprefs.gfx_filter_horiz_zoom, TRUE);
-                       SetDlgItemInt (hDlg, IDC_FILTERVZV, workprefs.gfx_filter_vert_zoom, TRUE);
                        init_colors ();
                        notice_new_xcolors ();
                        reset_drawing ();

diff --git a/od-win32/winuaechangelog.txt b/od-win32/winuaechangelog.txt
index ebebc97639a261a94d339c17297a711f1e684f92..4532c9840021a9a052798873d342e7b8ecc91852 100644 (file)
--- a/od-win32/winuaechangelog.txt
+++ b/od-win32/winuaechangelog.txt
@@ -1,4 +1,24 @@
 
+Beta 12:
+
+- emulate A3000 Fat Gary/RAMSEY configuration address space mirroring (no real world effect but I was testing
+  m68k AROS ROM on my A3000 and noticed this mirroring)
+- hrtmon 2.32->2.33 update
+- hrtmon didn't work in cycle-exact modes
+- MIDI device names are also stored in configuration file (overrides old style id numbers)
+- in auto resize and center filter modes 1x/2x.. modifiers change window size
+- manual filter configuration size adjustments added, saved to config file
+- RTG: do not refresh area outside of bitmap if bitmap is smaller than RTG screen resolution (AROS does this)
+- some read write-only custom register changes, bset (and other similar instructions) don't have previously
+  read prefetch data appearing in data lines when reading (like most other instructions do), data is zero.
+  This explains why buggy programs that for example bset #x,$dff096 don't mess up register contents too much.
+  (Fixes Kefrens Party Intro by Wiz, coder thought that bset #10,$dff096 is the right way to enable blitter nasty)
+- sample ripper ignored most samples (broken when audio emulation was rewritten in 2.3)
+- topmost scanline was usually not visible in autoscale modes
+- weak bit copy protected ipfs broke in earlier betas (only if using latest dll)
+
+Beta 11:
+
 - random RTG color errors when switching to/from fullscreen 8-bit RTG modes
 - emulate chipset feature where custom dma pointer register write is ignored if next cycle uses same register for Agnus DMA access
   (bitplanes added, sprites partially supported previously) fixes intro MoreNewStuffy by PlasmaForce

diff --git a/rommgr.cpp b/rommgr.cpp
index 7b3980e4785d4f05cdd9207ad6eb9216631eb447..3ae496a9946868b08162325a286f68fb0a09e42a 100644 (file)
--- a/rommgr.cpp
+++ b/rommgr.cpp
@@ -258,7 +258,7 @@ static struct romdata roms[] = {
        0x72850aef, 0x59c91d1f,0xa8f118f9,0x0bdba05a,0x9ae788d7,0x7a6cc7c9 },
        ALTROM(70, 1, 1, 32768, ROMTYPE_EVEN|ROMTYPE_SCRAMBLED|ROMTYPE_8BIT, 0xf3330e1f,0x3a597db2,0xb7d11b6c,0xb8e13496,0xc215f223,0x88c4ca3c)
        ALTROM(70, 1, 2, 32768, ROMTYPE_EVEN|ROMTYPE_SCRAMBLED|ROMTYPE_8BIT, 0xee58e0f9,0x4148f4cb,0xb42cec33,0x8ca144de,0xd4f54118,0xe0f185dd)
-       { L"Freezer: HRTMon v2.32 (built-in)", 0, 0, 0, 0, L"HRTMON\0", 0, 63, 0, 0, ROMTYPE_HRTMON, 0, 1, NULL,
+       { L"Freezer: HRTMon v2.33 (built-in)", 0, 0, 0, 0, L"HRTMON\0", 0, 63, 0, 0, ROMTYPE_HRTMON, 0, 1, NULL,
        0xffffffff, 0, 0, 0, 0, 0, L"HRTMon" },
 
        { L"A590/A2091 SCSI boot ROM", 6, 0, 6, 0, L"A590\0A2091\0", 16384, 53, 0, 0, ROMTYPE_A2091BOOT, 0, 0, NULL,