From: Toni Wilen Date: Thu, 17 Feb 2011 16:51:57 +0000 (+0200) Subject: 2310b12 X-Git-Tag: 2310~2 X-Git-Url: https://git.unchartedbackwaters.co.uk/w/?a=commitdiff_plain;h=e7d6f64da6ab5326c1daefbeab4c66c279006f96;p=francis%2Fwinuae.git 2310b12 --- diff --git a/audio.cpp b/audio.cpp index 411c685a..2fd3cf09 100644 --- 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 e1406280..0cd1b36a 100644 --- 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 9297a048..77edad0a 100644 --- 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 95ae58ca..8adf8375 100644 --- 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 2355f37a..17b65e73 100644 --- 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 index 00000000..488c74d4 --- /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_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 9c57244c..c9465b52 100644 --- 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 41400ca5..3714738c 100644 --- 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 fa2313f6..4a1d4a2c 100644 --- 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 8dad9023..d94a5b6c 100644 --- 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 af795950..441fe954 100644 --- 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 8f41d7dd..a8378862 100644 --- 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 7212e2de..d796c56d 100644 --- 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 0236dacd..b4428076 100644 --- 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 7d319329..a097c54f 100644 --- 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 4e7f2579..591814e4 100644 --- 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 9d54969c..50508276 100755 --- 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 -#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 406925ae..6ad30b25 100755 --- 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 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 799efbb0..7b5c380f 100644 --- 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 cc6f56b7..0c7454b5 100644 --- 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 e6c69856..8d32aad1 100644 --- 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 374beed9..e85a6849 100644 --- 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 6813bfe2..d9dab982 100644 --- 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 b016fdb5..020569ef 100644 --- 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 5ca52d38..67f3e29c 100644 --- 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 4886f3c5..626066cd 100644 --- 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 ebebc976..4532c984 100644 --- 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 7b3980e4..3ae496a9 100644 --- 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,