dlls/winepulse.drv/mmdevdrv.c

   1 /*
   2  * Copyright 2011-2012 Maarten Lankhorst
   3  * Copyright 2010-2011 Maarten Lankhorst for CodeWeavers
   4  * Copyright 2011 Andrew Eikum for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define NONAMELESSUNION
  22 #define COBJMACROS
  23 #define _GNU_SOURCE
  24
  25 #include "config.h"
  26 #include <poll.h>
  27 #include <pthread.h>
  28
  29 #include <stdarg.h>
  30 #include <unistd.h>
  31 #include <math.h>
  32 #include <stdio.h>
  33 #include <errno.h>
  34
  35 #include <pulse/pulseaudio.h>
  36
  37 #include "windef.h"
  38 #include "winbase.h"
  39 #include "winnls.h"
  40 #include "winreg.h"
  41 #include "wine/debug.h"
  42 #include "wine/unicode.h"
  43 #include "wine/list.h"
  44
  45 #include "ole2.h"
  46 #include "dshow.h"
  47 #include "dsound.h"
  48 #include "propsys.h"
  49
  50 #include "initguid.h"
  51 #include "ks.h"
  52 #include "ksmedia.h"
  53 #include "propkey.h"
  54 #include "mmdeviceapi.h"
  55 #include "audioclient.h"
  56 #include "endpointvolume.h"
  57 #include "audiopolicy.h"
  58
  59 WINE_DEFAULT_DEBUG_CHANNEL(pulse);
  60
  61 #define NULL_PTR_ERR MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, RPC_X_NULL_REF_POINTER)
  62
  63 /* From <dlls/mmdevapi/mmdevapi.h> */
  64 enum DriverPriority {
  65     Priority_Unavailable = 0,
  66     Priority_Low,
  67     Priority_Neutral,
  68     Priority_Preferred
  69 };
  70
  71 static const REFERENCE_TIME MinimumPeriod = 30000;
  72 static const REFERENCE_TIME DefaultPeriod = 100000;
  73
  74 static pa_context *pulse_ctx;
  75 static pa_mainloop *pulse_ml;
  76
  77 static HANDLE pulse_thread;
  78 static pthread_mutex_t pulse_lock;
  79 static pthread_cond_t pulse_cond = PTHREAD_COND_INITIALIZER;
  80 static struct list g_sessions = LIST_INIT(g_sessions);
  81
  82 static UINT g_phys_speakers_mask = 0;
  83
  84 /* Mixer format + period times */
  85 static WAVEFORMATEXTENSIBLE pulse_fmt[2];
  86 static REFERENCE_TIME pulse_min_period[2], pulse_def_period[2];
  87
  88 static GUID pulse_render_guid =
  89 { 0xfd47d9cc, 0x4218, 0x4135, { 0x9c, 0xe2, 0x0c, 0x19, 0x5c, 0x87, 0x40, 0x5b } };
  90 static GUID pulse_capture_guid =
  91 { 0x25da76d0, 0x033c, 0x4235, { 0x90, 0x02, 0x19, 0xf4, 0x88, 0x94, 0xac, 0x6f } };
  92
  93 static UINT8 mult_alaw_sample(UINT8, float);
  94 static UINT8 mult_ulaw_sample(UINT8, float);
  95
  96 BOOL WINAPI DllMain(HINSTANCE dll, DWORD reason, void *reserved)
  97 {
  98     if (reason == DLL_PROCESS_ATTACH) {
  99         pthread_mutexattr_t attr;
 100
 101         DisableThreadLibraryCalls(dll);
 102
 103         pthread_mutexattr_init(&attr);
 104         pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
 105
 106         if (pthread_mutex_init(&pulse_lock, &attr) != 0)
 107             pthread_mutex_init(&pulse_lock, NULL);
 108     } else if (reason == DLL_PROCESS_DETACH) {
 109         if (pulse_thread)
 110            SetThreadPriority(pulse_thread, 0);
 111         if (pulse_ctx) {
 112             pa_context_disconnect(pulse_ctx);
 113             pa_context_unref(pulse_ctx);
 114         }
 115         if (pulse_ml)
 116             pa_mainloop_quit(pulse_ml, 0);
 117         if (pulse_thread) {
 118             WaitForSingleObject(pulse_thread, INFINITE);
 119             CloseHandle(pulse_thread);
 120         }
 121     }
 122     return TRUE;
 123 }
 124
 125 typedef struct ACImpl ACImpl;
 126
 127 typedef struct _AudioSession {
 128     GUID guid;
 129     struct list clients;
 130
 131     IMMDevice *device;
 132
 133     float master_vol;
 134     UINT32 channel_count;
 135     float *channel_vols;
 136     BOOL mute;
 137
 138     struct list entry;
 139 } AudioSession;
 140
 141 typedef struct _AudioSessionWrapper {
 142     IAudioSessionControl2 IAudioSessionControl2_iface;
 143     IChannelAudioVolume IChannelAudioVolume_iface;
 144     ISimpleAudioVolume ISimpleAudioVolume_iface;
 145
 146     LONG ref;
 147
 148     ACImpl *client;
 149     AudioSession *session;
 150 } AudioSessionWrapper;
 151
 152 typedef struct _ACPacket {
 153     struct list entry;
 154     UINT64 qpcpos;
 155     BYTE *data;
 156     UINT32 discont;
 157 } ACPacket;
 158
 159 struct ACImpl {
 160     IAudioClient3 IAudioClient3_iface;
 161     IAudioRenderClient IAudioRenderClient_iface;
 162     IAudioCaptureClient IAudioCaptureClient_iface;
 163     IAudioClock IAudioClock_iface;
 164     IAudioClock2 IAudioClock2_iface;
 165     IAudioStreamVolume IAudioStreamVolume_iface;
 166     IUnknown *marshal;
 167     IMMDevice *parent;
 168     struct list entry;
 169     float vol[PA_CHANNELS_MAX];
 170
 171     LONG ref;
 172     EDataFlow dataflow;
 173     DWORD flags;
 174     AUDCLNT_SHAREMODE share;
 175     HANDLE event, timer;
 176
 177     INT32 locked;
 178     UINT32 bufsize_frames, real_bufsize_bytes, period_bytes;
 179     UINT32 started, peek_ofs, read_offs_bytes, lcl_offs_bytes, pa_offs_bytes;
 180     UINT32 tmp_buffer_bytes, held_bytes, peek_len, peek_buffer_len, pa_held_bytes;
 181     BYTE *local_buffer, *tmp_buffer, *peek_buffer;
 182     void *locked_ptr;
 183     BOOL please_quit, just_started, just_underran;
 184     pa_usec_t last_time, mmdev_period_usec;
 185
 186     pa_stream *stream;
 187     pa_sample_spec ss;
 188     pa_channel_map map;
 189     pa_buffer_attr attr;
 190
 191     INT64 clock_lastpos, clock_written;
 192
 193     AudioSession *session;
 194     AudioSessionWrapper *session_wrapper;
 195     struct list packet_free_head;
 196     struct list packet_filled_head;
 197 };
 198
 199 static const WCHAR defaultW[] = {'P','u','l','s','e','a','u','d','i','o',0};
 200
 201 static const IAudioClient3Vtbl AudioClient3_Vtbl;
 202 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl;
 203 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl;
 204 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl;
 205 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl;
 206 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl;
 207 static const IAudioClockVtbl AudioClock_Vtbl;
 208 static const IAudioClock2Vtbl AudioClock2_Vtbl;
 209 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl;
 210
 211 static AudioSessionWrapper *AudioSessionWrapper_Create(ACImpl *client);
 212
 213 static inline ACImpl *impl_from_IAudioClient3(IAudioClient3 *iface)
 214 {
 215     return CONTAINING_RECORD(iface, ACImpl, IAudioClient3_iface);
 216 }
 217
 218 static inline ACImpl *impl_from_IAudioRenderClient(IAudioRenderClient *iface)
 219 {
 220     return CONTAINING_RECORD(iface, ACImpl, IAudioRenderClient_iface);
 221 }
 222
 223 static inline ACImpl *impl_from_IAudioCaptureClient(IAudioCaptureClient *iface)
 224 {
 225     return CONTAINING_RECORD(iface, ACImpl, IAudioCaptureClient_iface);
 226 }
 227
 228 static inline AudioSessionWrapper *impl_from_IAudioSessionControl2(IAudioSessionControl2 *iface)
 229 {
 230     return CONTAINING_RECORD(iface, AudioSessionWrapper, IAudioSessionControl2_iface);
 231 }
 232
 233 static inline AudioSessionWrapper *impl_from_ISimpleAudioVolume(ISimpleAudioVolume *iface)
 234 {
 235     return CONTAINING_RECORD(iface, AudioSessionWrapper, ISimpleAudioVolume_iface);
 236 }
 237
 238 static inline AudioSessionWrapper *impl_from_IChannelAudioVolume(IChannelAudioVolume *iface)
 239 {
 240     return CONTAINING_RECORD(iface, AudioSessionWrapper, IChannelAudioVolume_iface);
 241 }
 242
 243 static inline ACImpl *impl_from_IAudioClock(IAudioClock *iface)
 244 {
 245     return CONTAINING_RECORD(iface, ACImpl, IAudioClock_iface);
 246 }
 247
 248 static inline ACImpl *impl_from_IAudioClock2(IAudioClock2 *iface)
 249 {
 250     return CONTAINING_RECORD(iface, ACImpl, IAudioClock2_iface);
 251 }
 252
 253 static inline ACImpl *impl_from_IAudioStreamVolume(IAudioStreamVolume *iface)
 254 {
 255     return CONTAINING_RECORD(iface, ACImpl, IAudioStreamVolume_iface);
 256 }
 257
 258 /* Following pulseaudio design here, mainloop has the lock taken whenever
 259  * it is handling something for pulse, and the lock is required whenever
 260  * doing any pa_* call that can affect the state in any way
 261  *
 262  * pa_cond_wait is used when waiting on results, because the mainloop needs
 263  * the same lock taken to affect the state
 264  *
 265  * This is basically the same as the pa_threaded_mainloop implementation,
 266  * but that cannot be used because it uses pthread_create directly
 267  *
 268  * pa_threaded_mainloop_(un)lock -> pthread_mutex_(un)lock
 269  * pa_threaded_mainloop_signal -> pthread_cond_broadcast
 270  * pa_threaded_mainloop_wait -> pthread_cond_wait
 271  */
 272
 273 static int pulse_poll_func(struct pollfd *ufds, unsigned long nfds, int timeout, void *userdata) {
 274     int r;
 275     pthread_mutex_unlock(&pulse_lock);
 276     r = poll(ufds, nfds, timeout);
 277     pthread_mutex_lock(&pulse_lock);
 278     return r;
 279 }
 280
 281 static DWORD CALLBACK pulse_mainloop_thread(void *tmp) {
 282     int ret;
 283     pulse_ml = pa_mainloop_new();
 284     pa_mainloop_set_poll_func(pulse_ml, pulse_poll_func, NULL);
 285     pthread_mutex_lock(&pulse_lock);
 286     pthread_cond_broadcast(&pulse_cond);
 287     pa_mainloop_run(pulse_ml, &ret);
 288     pthread_mutex_unlock(&pulse_lock);
 289     pa_mainloop_free(pulse_ml);
 290     return ret;
 291 }
 292
 293 static void pulse_contextcallback(pa_context *c, void *userdata)
 294 {
 295     switch (pa_context_get_state(c)) {
 296         default:
 297             FIXME("Unhandled state: %i\n", pa_context_get_state(c));
 298             return;
 299
 300         case PA_CONTEXT_CONNECTING:
 301         case PA_CONTEXT_UNCONNECTED:
 302         case PA_CONTEXT_AUTHORIZING:
 303         case PA_CONTEXT_SETTING_NAME:
 304         case PA_CONTEXT_TERMINATED:
 305             TRACE("State change to %i\n", pa_context_get_state(c));
 306             return;
 307
 308         case PA_CONTEXT_READY:
 309             TRACE("Ready\n");
 310             break;
 311
 312         case PA_CONTEXT_FAILED:
 313             WARN("Context failed: %s\n", pa_strerror(pa_context_errno(c)));
 314             break;
 315     }
 316     pthread_cond_broadcast(&pulse_cond);
 317 }
 318
 319 static void pulse_stream_state(pa_stream *s, void *user)
 320 {
 321     pa_stream_state_t state = pa_stream_get_state(s);
 322     TRACE("Stream state changed to %i\n", state);
 323     pthread_cond_broadcast(&pulse_cond);
 324 }
 325
 326 static const enum pa_channel_position pulse_pos_from_wfx[] = {
 327     PA_CHANNEL_POSITION_FRONT_LEFT,
 328     PA_CHANNEL_POSITION_FRONT_RIGHT,
 329     PA_CHANNEL_POSITION_FRONT_CENTER,
 330     PA_CHANNEL_POSITION_LFE,
 331     PA_CHANNEL_POSITION_REAR_LEFT,
 332     PA_CHANNEL_POSITION_REAR_RIGHT,
 333     PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER,
 334     PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER,
 335     PA_CHANNEL_POSITION_REAR_CENTER,
 336     PA_CHANNEL_POSITION_SIDE_LEFT,
 337     PA_CHANNEL_POSITION_SIDE_RIGHT,
 338     PA_CHANNEL_POSITION_TOP_CENTER,
 339     PA_CHANNEL_POSITION_TOP_FRONT_LEFT,
 340     PA_CHANNEL_POSITION_TOP_FRONT_CENTER,
 341     PA_CHANNEL_POSITION_TOP_FRONT_RIGHT,
 342     PA_CHANNEL_POSITION_TOP_REAR_LEFT,
 343     PA_CHANNEL_POSITION_TOP_REAR_CENTER,
 344     PA_CHANNEL_POSITION_TOP_REAR_RIGHT
 345 };
 346
 347 static DWORD pulse_channel_map_to_channel_mask(const pa_channel_map *map)
 348 {
 349     int i;
 350     DWORD mask = 0;
 351
 352     for (i = 0; i < map->channels; ++i) {
 353         switch (map->map[i]) {
 354             default: FIXME("Unhandled channel %s\n", pa_channel_position_to_string(map->map[i])); break;
 355             case PA_CHANNEL_POSITION_FRONT_LEFT: mask |= SPEAKER_FRONT_LEFT; break;
 356             case PA_CHANNEL_POSITION_MONO:
 357             case PA_CHANNEL_POSITION_FRONT_CENTER: mask |= SPEAKER_FRONT_CENTER; break;
 358             case PA_CHANNEL_POSITION_FRONT_RIGHT: mask |= SPEAKER_FRONT_RIGHT; break;
 359             case PA_CHANNEL_POSITION_REAR_LEFT: mask |= SPEAKER_BACK_LEFT; break;
 360             case PA_CHANNEL_POSITION_REAR_CENTER: mask |= SPEAKER_BACK_CENTER; break;
 361             case PA_CHANNEL_POSITION_REAR_RIGHT: mask |= SPEAKER_BACK_RIGHT; break;
 362             case PA_CHANNEL_POSITION_LFE: mask |= SPEAKER_LOW_FREQUENCY; break;
 363             case PA_CHANNEL_POSITION_SIDE_LEFT: mask |= SPEAKER_SIDE_LEFT; break;
 364             case PA_CHANNEL_POSITION_SIDE_RIGHT: mask |= SPEAKER_SIDE_RIGHT; break;
 365             case PA_CHANNEL_POSITION_TOP_CENTER: mask |= SPEAKER_TOP_CENTER; break;
 366             case PA_CHANNEL_POSITION_TOP_FRONT_LEFT: mask |= SPEAKER_TOP_FRONT_LEFT; break;
 367             case PA_CHANNEL_POSITION_TOP_FRONT_CENTER: mask |= SPEAKER_TOP_FRONT_CENTER; break;
 368             case PA_CHANNEL_POSITION_TOP_FRONT_RIGHT: mask |= SPEAKER_TOP_FRONT_RIGHT; break;
 369             case PA_CHANNEL_POSITION_TOP_REAR_LEFT: mask |= SPEAKER_TOP_BACK_LEFT; break;
 370             case PA_CHANNEL_POSITION_TOP_REAR_CENTER: mask |= SPEAKER_TOP_BACK_CENTER; break;
 371             case PA_CHANNEL_POSITION_TOP_REAR_RIGHT: mask |= SPEAKER_TOP_BACK_RIGHT; break;
 372             case PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER: mask |= SPEAKER_FRONT_LEFT_OF_CENTER; break;
 373             case PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER: mask |= SPEAKER_FRONT_RIGHT_OF_CENTER; break;
 374         }
 375     }
 376
 377     return mask;
 378 }
 379
 380 /* For most hardware on Windows, users must choose a configuration with an even
 381  * number of channels (stereo, quad, 5.1, 7.1). Users can then disable
 382  * channels, but those channels are still reported to applications from
 383  * GetMixFormat! Some applications behave badly if given an odd number of
 384  * channels (e.g. 2.1).  Here, we find the nearest configuration that Windows
 385  * would report for a given channel layout. */
 386 static void convert_channel_map(const pa_channel_map *pa_map, WAVEFORMATEXTENSIBLE *fmt)
 387 {
 388     DWORD pa_mask = pulse_channel_map_to_channel_mask(pa_map);
 389
 390     TRACE("got mask for PA: 0x%x\n", pa_mask);
 391
 392     if (pa_map->channels == 1)
 393     {
 394         fmt->Format.nChannels = 1;
 395         fmt->dwChannelMask = pa_mask;
 396         return;
 397     }
 398
 399     /* compare against known configurations and find smallest configuration
 400      * which is a superset of the given speakers */
 401
 402     if (pa_map->channels <= 2 &&
 403             (pa_mask & ~KSAUDIO_SPEAKER_STEREO) == 0)
 404     {
 405         fmt->Format.nChannels = 2;
 406         fmt->dwChannelMask = KSAUDIO_SPEAKER_STEREO;
 407         return;
 408     }
 409
 410     if (pa_map->channels <= 4 &&
 411             (pa_mask & ~KSAUDIO_SPEAKER_QUAD) == 0)
 412     {
 413         fmt->Format.nChannels = 4;
 414         fmt->dwChannelMask = KSAUDIO_SPEAKER_QUAD;
 415         return;
 416     }
 417
 418     if (pa_map->channels <= 4 &&
 419             (pa_mask & ~KSAUDIO_SPEAKER_SURROUND) == 0)
 420     {
 421         fmt->Format.nChannels = 4;
 422         fmt->dwChannelMask = KSAUDIO_SPEAKER_SURROUND;
 423         return;
 424     }
 425
 426     if (pa_map->channels <= 6 &&
 427             (pa_mask & ~KSAUDIO_SPEAKER_5POINT1) == 0)
 428     {
 429         fmt->Format.nChannels = 6;
 430         fmt->dwChannelMask = KSAUDIO_SPEAKER_5POINT1;
 431         return;
 432     }
 433
 434     if (pa_map->channels <= 6 &&
 435             (pa_mask & ~KSAUDIO_SPEAKER_5POINT1_SURROUND) == 0)
 436     {
 437         fmt->Format.nChannels = 6;
 438         fmt->dwChannelMask = KSAUDIO_SPEAKER_5POINT1_SURROUND;
 439         return;
 440     }
 441
 442     if (pa_map->channels <= 8 &&
 443             (pa_mask & ~KSAUDIO_SPEAKER_7POINT1) == 0)
 444     {
 445         fmt->Format.nChannels = 8;
 446         fmt->dwChannelMask = KSAUDIO_SPEAKER_7POINT1;
 447         return;
 448     }
 449
 450     if (pa_map->channels <= 8 &&
 451             (pa_mask & ~KSAUDIO_SPEAKER_7POINT1_SURROUND) == 0)
 452     {
 453         fmt->Format.nChannels = 8;
 454         fmt->dwChannelMask = KSAUDIO_SPEAKER_7POINT1_SURROUND;
 455         return;
 456     }
 457
 458     /* oddball format, report truthfully */
 459     fmt->Format.nChannels = pa_map->channels;
 460     fmt->dwChannelMask = pa_mask;
 461 }
 462
 463 static void pulse_probe_settings(int render, WAVEFORMATEXTENSIBLE *fmt) {
 464     WAVEFORMATEX *wfx = &fmt->Format;
 465     pa_stream *stream;
 466     pa_channel_map map;
 467     pa_sample_spec ss;
 468     pa_buffer_attr attr;
 469     int ret;
 470     unsigned int length = 0;
 471
 472     pa_channel_map_init_auto(&map, 2, PA_CHANNEL_MAP_ALSA);
 473     ss.rate = 48000;
 474     ss.format = PA_SAMPLE_FLOAT32LE;
 475     ss.channels = map.channels;
 476
 477     attr.maxlength = -1;
 478     attr.tlength = -1;
 479     attr.minreq = attr.fragsize = pa_frame_size(&ss);
 480     attr.prebuf = 0;
 481
 482     stream = pa_stream_new(pulse_ctx, "format test stream", &ss, &map);
 483     if (stream)
 484         pa_stream_set_state_callback(stream, pulse_stream_state, NULL);
 485     if (!stream)
 486         ret = -1;
 487     else if (render)
 488         ret = pa_stream_connect_playback(stream, NULL, &attr,
 489         PA_STREAM_START_CORKED|PA_STREAM_FIX_RATE|PA_STREAM_FIX_CHANNELS|PA_STREAM_EARLY_REQUESTS, NULL, NULL);
 490     else
 491         ret = pa_stream_connect_record(stream, NULL, &attr, PA_STREAM_START_CORKED|PA_STREAM_FIX_RATE|PA_STREAM_FIX_CHANNELS|PA_STREAM_EARLY_REQUESTS);
 492     if (ret >= 0) {
 493         while (pa_mainloop_iterate(pulse_ml, 1, &ret) >= 0 &&
 494                 pa_stream_get_state(stream) == PA_STREAM_CREATING)
 495         {}
 496         if (pa_stream_get_state(stream) == PA_STREAM_READY) {
 497             ss = *pa_stream_get_sample_spec(stream);
 498             map = *pa_stream_get_channel_map(stream);
 499             if (render)
 500                 length = pa_stream_get_buffer_attr(stream)->minreq;
 501             else
 502                 length = pa_stream_get_buffer_attr(stream)->fragsize;
 503             pa_stream_disconnect(stream);
 504             while (pa_mainloop_iterate(pulse_ml, 1, &ret) >= 0 &&
 505                     pa_stream_get_state(stream) == PA_STREAM_READY)
 506             {}
 507         }
 508     }
 509
 510     if (stream)
 511         pa_stream_unref(stream);
 512
 513     if (length)
 514         pulse_def_period[!render] = pulse_min_period[!render] = pa_bytes_to_usec(10 * length, &ss);
 515
 516     if (pulse_min_period[!render] < MinimumPeriod)
 517         pulse_min_period[!render] = MinimumPeriod;
 518
 519     if (pulse_def_period[!render] < DefaultPeriod)
 520         pulse_def_period[!render] = DefaultPeriod;
 521
 522     wfx->wFormatTag = WAVE_FORMAT_EXTENSIBLE;
 523     wfx->cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
 524
 525     convert_channel_map(&map, fmt);
 526
 527     wfx->wBitsPerSample = 8 * pa_sample_size_of_format(ss.format);
 528     wfx->nSamplesPerSec = ss.rate;
 529     wfx->nBlockAlign = wfx->nChannels * wfx->wBitsPerSample / 8;
 530     wfx->nAvgBytesPerSec = wfx->nSamplesPerSec * wfx->nBlockAlign;
 531     if (ss.format != PA_SAMPLE_S24_32LE)
 532         fmt->Samples.wValidBitsPerSample = wfx->wBitsPerSample;
 533     else
 534         fmt->Samples.wValidBitsPerSample = 24;
 535     if (ss.format == PA_SAMPLE_FLOAT32LE)
 536         fmt->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
 537     else
 538         fmt->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 539 }
 540
 541 static HRESULT pulse_connect(void)
 542 {
 543     int len;
 544     WCHAR path[MAX_PATH], *name;
 545     char *str;
 546
 547     if (!pulse_thread)
 548     {
 549         if (!(pulse_thread = CreateThread(NULL, 0, pulse_mainloop_thread, NULL, 0, NULL)))
 550         {
 551             ERR("Failed to create mainloop thread.\n");
 552             return E_FAIL;
 553         }
 554         SetThreadPriority(pulse_thread, THREAD_PRIORITY_TIME_CRITICAL);
 555         pthread_cond_wait(&pulse_cond, &pulse_lock);
 556     }
 557
 558     if (pulse_ctx && PA_CONTEXT_IS_GOOD(pa_context_get_state(pulse_ctx)))
 559         return S_OK;
 560     if (pulse_ctx)
 561         pa_context_unref(pulse_ctx);
 562
 563     GetModuleFileNameW(NULL, path, ARRAY_SIZE(path));
 564     name = strrchrW(path, '\\');
 565     if (!name)
 566         name = path;
 567     else
 568         name++;
 569     len = WideCharToMultiByte(CP_UNIXCP, 0, name, -1, NULL, 0, NULL, NULL);
 570     str = pa_xmalloc(len);
 571     WideCharToMultiByte(CP_UNIXCP, 0, name, -1, str, len, NULL, NULL);
 572     TRACE("Name: %s\n", str);
 573     pulse_ctx = pa_context_new(pa_mainloop_get_api(pulse_ml), str);
 574     pa_xfree(str);
 575     if (!pulse_ctx) {
 576         ERR("Failed to create context\n");
 577         return E_FAIL;
 578     }
 579
 580     pa_context_set_state_callback(pulse_ctx, pulse_contextcallback, NULL);
 581
 582     TRACE("libpulse protocol version: %u. API Version %u\n", pa_context_get_protocol_version(pulse_ctx), PA_API_VERSION);
 583     if (pa_context_connect(pulse_ctx, NULL, 0, NULL) < 0)
 584         goto fail;
 585
 586     /* Wait for connection */
 587     while (pthread_cond_wait(&pulse_cond, &pulse_lock)) {
 588         pa_context_state_t state = pa_context_get_state(pulse_ctx);
 589
 590         if (state == PA_CONTEXT_FAILED || state == PA_CONTEXT_TERMINATED)
 591             goto fail;
 592
 593         if (state == PA_CONTEXT_READY)
 594             break;
 595     }
 596
 597     TRACE("Connected to server %s with protocol version: %i.\n",
 598         pa_context_get_server(pulse_ctx),
 599         pa_context_get_server_protocol_version(pulse_ctx));
 600     return S_OK;
 601
 602 fail:
 603     pa_context_unref(pulse_ctx);
 604     pulse_ctx = NULL;
 605     return E_FAIL;
 606 }
 607
 608 /* For default PulseAudio render device, OR together all of the
 609  * PKEY_AudioEndpoint_PhysicalSpeakers values of the sinks. */
 610 static void pulse_phys_speakers_cb(pa_context *c, const pa_sink_info *i, int eol, void *userdata)
 611 {
 612     if (i)
 613         g_phys_speakers_mask |= pulse_channel_map_to_channel_mask(&i->channel_map);
 614 }
 615
 616 /* some poorly-behaved applications call audio functions during DllMain, so we
 617  * have to do as much as possible without creating a new thread. this function
 618  * sets up a synchronous connection to verify the server is running and query
 619  * static data. */
 620 static HRESULT pulse_test_connect(void)
 621 {
 622     int len, ret;
 623     WCHAR path[MAX_PATH], *name;
 624     char *str;
 625     pa_operation *o;
 626
 627     pulse_ml = pa_mainloop_new();
 628
 629     pa_mainloop_set_poll_func(pulse_ml, pulse_poll_func, NULL);
 630
 631     GetModuleFileNameW(NULL, path, ARRAY_SIZE(path));
 632     name = strrchrW(path, '\\');
 633     if (!name)
 634         name = path;
 635     else
 636         name++;
 637     len = WideCharToMultiByte(CP_UNIXCP, 0, name, -1, NULL, 0, NULL, NULL);
 638     str = pa_xmalloc(len);
 639     WideCharToMultiByte(CP_UNIXCP, 0, name, -1, str, len, NULL, NULL);
 640     TRACE("Name: %s\n", str);
 641     pulse_ctx = pa_context_new(pa_mainloop_get_api(pulse_ml), str);
 642     pa_xfree(str);
 643     if (!pulse_ctx) {
 644         ERR("Failed to create context\n");
 645         pa_mainloop_free(pulse_ml);
 646         pulse_ml = NULL;
 647         return E_FAIL;
 648     }
 649
 650     pa_context_set_state_callback(pulse_ctx, pulse_contextcallback, NULL);
 651
 652     TRACE("libpulse protocol version: %u. API Version %u\n", pa_context_get_protocol_version(pulse_ctx), PA_API_VERSION);
 653     if (pa_context_connect(pulse_ctx, NULL, 0, NULL) < 0)
 654         goto fail;
 655
 656     /* Wait for connection */
 657     while (pa_mainloop_iterate(pulse_ml, 1, &ret) >= 0) {
 658         pa_context_state_t state = pa_context_get_state(pulse_ctx);
 659
 660         if (state == PA_CONTEXT_FAILED || state == PA_CONTEXT_TERMINATED)
 661             goto fail;
 662
 663         if (state == PA_CONTEXT_READY)
 664             break;
 665     }
 666
 667     if (pa_context_get_state(pulse_ctx) != PA_CONTEXT_READY)
 668         goto fail;
 669
 670     TRACE("Test-connected to server %s with protocol version: %i.\n",
 671         pa_context_get_server(pulse_ctx),
 672         pa_context_get_server_protocol_version(pulse_ctx));
 673
 674     pulse_probe_settings(1, &pulse_fmt[0]);
 675     pulse_probe_settings(0, &pulse_fmt[1]);
 676
 677     g_phys_speakers_mask = 0;
 678     o = pa_context_get_sink_info_list(pulse_ctx, &pulse_phys_speakers_cb, NULL);
 679     if (o) {
 680         while (pa_mainloop_iterate(pulse_ml, 1, &ret) >= 0 &&
 681                 pa_operation_get_state(o) == PA_OPERATION_RUNNING)
 682         {}
 683         pa_operation_unref(o);
 684     }
 685
 686     pa_context_unref(pulse_ctx);
 687     pulse_ctx = NULL;
 688     pa_mainloop_free(pulse_ml);
 689     pulse_ml = NULL;
 690
 691     return S_OK;
 692
 693 fail:
 694     pa_context_unref(pulse_ctx);
 695     pulse_ctx = NULL;
 696     pa_mainloop_free(pulse_ml);
 697     pulse_ml = NULL;
 698
 699     return E_FAIL;
 700 }
 701
 702 static HRESULT pulse_stream_valid(ACImpl *This) {
 703     if (!This->stream)
 704         return AUDCLNT_E_NOT_INITIALIZED;
 705     if (pa_stream_get_state(This->stream) != PA_STREAM_READY)
 706         return AUDCLNT_E_DEVICE_INVALIDATED;
 707     return S_OK;
 708 }
 709
 710 static void silence_buffer(pa_sample_format_t format, BYTE *buffer, UINT32 bytes)
 711 {
 712     memset(buffer, format == PA_SAMPLE_U8 ? 0x80 : 0, bytes);
 713 }
 714
 715 static int write_buffer(const ACImpl *This, BYTE *buffer, UINT32 bytes)
 716 {
 717     float vol[PA_CHANNELS_MAX];
 718     BOOL adjust = FALSE;
 719     UINT32 i, channels;
 720     BYTE *end;
 721
 722     if (!bytes) return 0;
 723     if (This->session->mute)
 724     {
 725         silence_buffer(This->ss.format, buffer, bytes);
 726         goto write;
 727     }
 728
 729     /* Adjust the buffer based on the volume for each channel */
 730     channels = This->ss.channels;
 731     for (i = 0; i < channels; i++)
 732     {
 733         vol[i] = This->vol[i] * This->session->master_vol * This->session->channel_vols[i];
 734         adjust |= vol[i] != 1.0f;
 735     }
 736     if (!adjust) goto write;
 737
 738     end = buffer + bytes;
 739     switch (This->ss.format)
 740     {
 741 #ifndef WORDS_BIGENDIAN
 742 #define PROCESS_BUFFER(type) do         \
 743 {                                       \
 744     type *p = (type*)buffer;            \
 745     do                                  \
 746     {                                   \
 747         for (i = 0; i < channels; i++)  \
 748             p[i] = p[i] * vol[i];       \
 749         p += i;                         \
 750     } while ((BYTE*)p != end);          \
 751 } while (0)
 752     case PA_SAMPLE_S16LE:
 753         PROCESS_BUFFER(INT16);
 754         break;
 755     case PA_SAMPLE_S32LE:
 756         PROCESS_BUFFER(INT32);
 757         break;
 758     case PA_SAMPLE_FLOAT32LE:
 759         PROCESS_BUFFER(float);
 760         break;
 761 #undef PROCESS_BUFFER
 762     case PA_SAMPLE_S24_32LE:
 763     {
 764         UINT32 *p = (UINT32*)buffer;
 765         do
 766         {
 767             for (i = 0; i < channels; i++)
 768             {
 769                 p[i] = (INT32)((INT32)(p[i] << 8) * vol[i]);
 770                 p[i] >>= 8;
 771             }
 772             p += i;
 773         } while ((BYTE*)p != end);
 774         break;
 775     }
 776     case PA_SAMPLE_S24LE:
 777     {
 778         /* do it 12 bytes at a time until it is no longer possible */
 779         UINT32 *q = (UINT32*)buffer;
 780         BYTE *p;
 781
 782         i = 0;
 783         while (end - (BYTE*)q >= 12)
 784         {
 785             UINT32 v[4], k;
 786             v[0] = q[0] << 8;
 787             v[1] = q[1] << 16 | (q[0] >> 16 & ~0xff);
 788             v[2] = q[2] << 24 | (q[1] >> 8  & ~0xff);
 789             v[3] = q[2] & ~0xff;
 790             for (k = 0; k < 4; k++)
 791             {
 792                 v[k] = (INT32)((INT32)v[k] * vol[i]);
 793                 if (++i == channels) i = 0;
 794             }
 795             *q++ = v[0] >> 8  | (v[1] & ~0xff) << 16;
 796             *q++ = v[1] >> 16 | (v[2] & ~0xff) << 8;
 797             *q++ = v[2] >> 24 | (v[3] & ~0xff);
 798         }
 799         p = (BYTE*)q;
 800         while (p != end)
 801         {
 802             UINT32 v = (INT32)((INT32)(p[0] << 8 | p[1] << 16 | p[2] << 24) * vol[i]);
 803             *p++ = v >> 8  & 0xff;
 804             *p++ = v >> 16 & 0xff;
 805             *p++ = v >> 24;
 806             if (++i == channels) i = 0;
 807         }
 808         break;
 809     }
 810 #endif
 811     case PA_SAMPLE_U8:
 812     {
 813         UINT8 *p = (UINT8*)buffer;
 814         do
 815         {
 816             for (i = 0; i < channels; i++)
 817                 p[i] = (int)((p[i] - 128) * vol[i]) + 128;
 818             p += i;
 819         } while ((BYTE*)p != end);
 820         break;
 821     }
 822     case PA_SAMPLE_ALAW:
 823     {
 824         UINT8 *p = (UINT8*)buffer;
 825         do
 826         {
 827             for (i = 0; i < channels; i++)
 828                 p[i] = mult_alaw_sample(p[i], vol[i]);
 829             p += i;
 830         } while ((BYTE*)p != end);
 831         break;
 832     }
 833     case PA_SAMPLE_ULAW:
 834     {
 835         UINT8 *p = (UINT8*)buffer;
 836         do
 837         {
 838             for (i = 0; i < channels; i++)
 839                 p[i] = mult_ulaw_sample(p[i], vol[i]);
 840             p += i;
 841         } while ((BYTE*)p != end);
 842         break;
 843     }
 844     default:
 845         TRACE("Unhandled format %i, not adjusting volume.\n", This->ss.format);
 846         break;
 847     }
 848
 849 write:
 850     return pa_stream_write(This->stream, buffer, bytes, NULL, 0, PA_SEEK_RELATIVE);
 851 }
 852
 853 static void dump_attr(const pa_buffer_attr *attr) {
 854     TRACE("maxlength: %u\n", attr->maxlength);
 855     TRACE("minreq: %u\n", attr->minreq);
 856     TRACE("fragsize: %u\n", attr->fragsize);
 857     TRACE("tlength: %u\n", attr->tlength);
 858     TRACE("prebuf: %u\n", attr->prebuf);
 859 }
 860
 861 static void pulse_op_cb(pa_stream *s, int success, void *user) {
 862     TRACE("Success: %i\n", success);
 863     *(int*)user = success;
 864     pthread_cond_broadcast(&pulse_cond);
 865 }
 866
 867 static void pulse_attr_update(pa_stream *s, void *user) {
 868     const pa_buffer_attr *attr = pa_stream_get_buffer_attr(s);
 869     TRACE("New attributes or device moved:\n");
 870     dump_attr(attr);
 871 }
 872
 873 static void pulse_write(ACImpl *This)
 874 {
 875     /* write as much data to PA as we can */
 876     UINT32 to_write;
 877     BYTE *buf = This->local_buffer + This->pa_offs_bytes;
 878     UINT32 bytes = pa_stream_writable_size(This->stream);
 879
 880     if(This->just_underran){
 881         /* prebuffer with silence if needed */
 882         if(This->pa_held_bytes < bytes){
 883             to_write = bytes - This->pa_held_bytes;
 884             TRACE("prebuffering %u frames of silence\n",
 885                     (int)(to_write / pa_frame_size(&This->ss)));
 886             buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, to_write);
 887             pa_stream_write(This->stream, buf, to_write, NULL, 0, PA_SEEK_RELATIVE);
 888             HeapFree(GetProcessHeap(), 0, buf);
 889         }
 890
 891         This->just_underran = FALSE;
 892     }
 893
 894     buf = This->local_buffer + This->pa_offs_bytes;
 895     TRACE("held: %u, avail: %u\n",
 896             This->pa_held_bytes, bytes);
 897     bytes = min(This->pa_held_bytes, bytes);
 898
 899     if(This->pa_offs_bytes + bytes > This->real_bufsize_bytes){
 900         to_write = This->real_bufsize_bytes - This->pa_offs_bytes;
 901         TRACE("writing small chunk of %u bytes\n", to_write);
 902         write_buffer(This, buf, to_write);
 903         This->pa_held_bytes -= to_write;
 904         to_write = bytes - to_write;
 905         This->pa_offs_bytes = 0;
 906         buf = This->local_buffer;
 907     }else
 908         to_write = bytes;
 909
 910     TRACE("writing main chunk of %u bytes\n", to_write);
 911     write_buffer(This, buf, to_write);
 912     This->pa_offs_bytes += to_write;
 913     This->pa_offs_bytes %= This->real_bufsize_bytes;
 914     This->pa_held_bytes -= to_write;
 915 }
 916
 917 static void pulse_underflow_callback(pa_stream *s, void *userdata)
 918 {
 919     ACImpl *This = userdata;
 920     WARN("%p: Underflow\n", userdata);
 921     This->just_underran = TRUE;
 922     /* re-sync */
 923     This->pa_offs_bytes = This->lcl_offs_bytes;
 924     This->pa_held_bytes = This->held_bytes;
 925 }
 926
 927 static void pulse_started_callback(pa_stream *s, void *userdata)
 928 {
 929     TRACE("%p: (Re)started playing\n", userdata);
 930 }
 931
 932 static void pulse_read(ACImpl *This)
 933 {
 934     size_t bytes = pa_stream_readable_size(This->stream);
 935
 936     TRACE("Readable total: %zu, fragsize: %u\n", bytes, pa_stream_get_buffer_attr(This->stream)->fragsize);
 937
 938     bytes += This->peek_len - This->peek_ofs;
 939
 940     while (bytes >= This->period_bytes) {
 941         BYTE *dst = NULL, *src;
 942         size_t src_len, copy, rem = This->period_bytes;
 943
 944         if (This->started) {
 945             LARGE_INTEGER stamp, freq;
 946             ACPacket *p, *next;
 947
 948             if (!(p = (ACPacket*)list_head(&This->packet_free_head))) {
 949                 p = (ACPacket*)list_head(&This->packet_filled_head);
 950                 if (!p) return;
 951                 if (!p->discont) {
 952                     next = (ACPacket*)p->entry.next;
 953                     next->discont = 1;
 954                 } else
 955                     p = (ACPacket*)list_tail(&This->packet_filled_head);
 956             } else {
 957                 This->held_bytes += This->period_bytes;
 958             }
 959             QueryPerformanceCounter(&stamp);
 960             QueryPerformanceFrequency(&freq);
 961             p->qpcpos = (stamp.QuadPart * (INT64)10000000) / freq.QuadPart;
 962             p->discont = 0;
 963             list_remove(&p->entry);
 964             list_add_tail(&This->packet_filled_head, &p->entry);
 965
 966             dst = p->data;
 967         }
 968
 969         while (rem) {
 970             if (This->peek_len) {
 971                 copy = min(rem, This->peek_len - This->peek_ofs);
 972
 973                 if (dst) {
 974                     memcpy(dst, This->peek_buffer + This->peek_ofs, copy);
 975                     dst += copy;
 976                 }
 977
 978                 rem -= copy;
 979                 This->peek_ofs += copy;
 980                 if(This->peek_len == This->peek_ofs)
 981                     This->peek_len = This->peek_ofs = 0;
 982
 983             } else if (pa_stream_peek(This->stream, (const void**)&src, &src_len) == 0 && src_len) {
 984
 985                 copy = min(rem, src_len);
 986
 987                 if (dst) {
 988                     if(src)
 989                         memcpy(dst, src, copy);
 990                     else
 991                         silence_buffer(This->ss.format, dst, copy);
 992
 993                     dst += copy;
 994                 }
 995
 996                 rem -= copy;
 997
 998                 if (copy < src_len) {
 999                     if (src_len > This->peek_buffer_len) {
1000                         HeapFree(GetProcessHeap(), 0, This->peek_buffer);
1001                         This->peek_buffer = HeapAlloc(GetProcessHeap(), 0, src_len);
1002                         This->peek_buffer_len = src_len;
1003                     }
1004
1005                     if(src)
1006                         memcpy(This->peek_buffer, src + copy, src_len - copy);
1007                     else
1008                         silence_buffer(This->ss.format, This->peek_buffer, src_len - copy);
1009
1010                     This->peek_len = src_len - copy;
1011                     This->peek_ofs = 0;
1012                 }
1013
1014                 pa_stream_drop(This->stream);
1015             }
1016         }
1017
1018         bytes -= This->period_bytes;
1019     }
1020 }
1021
1022 static DWORD WINAPI pulse_timer_cb(void *user)
1023 {
1024     DWORD delay;
1025     UINT32 adv_bytes;
1026     ACImpl *This = user;
1027     int success;
1028     pa_operation *o;
1029
1030     pthread_mutex_lock(&pulse_lock);
1031     delay = This->mmdev_period_usec / 1000;
1032     pa_stream_get_time(This->stream, &This->last_time);
1033     pthread_mutex_unlock(&pulse_lock);
1034
1035     while(!This->please_quit){
1036         pa_usec_t now, adv_usec = 0;
1037         int err;
1038
1039         Sleep(delay);
1040
1041         pthread_mutex_lock(&pulse_lock);
1042
1043         delay = This->mmdev_period_usec / 1000;
1044
1045         o = pa_stream_update_timing_info(This->stream, pulse_op_cb, &success);
1046         if (o)
1047         {
1048             while (pa_operation_get_state(o) == PA_OPERATION_RUNNING)
1049                 pthread_cond_wait(&pulse_cond, &pulse_lock);
1050             pa_operation_unref(o);
1051         }
1052         err = pa_stream_get_time(This->stream, &now);
1053         if(err == 0){
1054             TRACE("got now: %s, last time: %s\n", wine_dbgstr_longlong(now), wine_dbgstr_longlong(This->last_time));
1055             if(This->started && (This->dataflow == eCapture || This->held_bytes)){
1056                 if(This->just_underran){
1057                     This->last_time = now;
1058                     This->just_started = TRUE;
1059                 }
1060
1061                 if(This->just_started){
1062                     /* let it play out a period to absorb some latency and get accurate timing */
1063                     pa_usec_t diff = now - This->last_time;
1064
1065                     if(diff > This->mmdev_period_usec){
1066                         This->just_started = FALSE;
1067                         This->last_time = now;
1068                     }
1069                 }else{
1070                     INT32 adjust = This->last_time + This->mmdev_period_usec - now;
1071
1072                     adv_usec = now - This->last_time;
1073
1074                     if(adjust > ((INT32)(This->mmdev_period_usec / 2)))
1075                         adjust = This->mmdev_period_usec / 2;
1076                     else if(adjust < -((INT32)(This->mmdev_period_usec / 2)))
1077                         adjust = -1 * This->mmdev_period_usec / 2;
1078
1079                     delay = (This->mmdev_period_usec + adjust) / 1000;
1080
1081                     This->last_time += This->mmdev_period_usec;
1082                 }
1083
1084                 if(This->dataflow == eRender){
1085                     pulse_write(This);
1086
1087                     /* regardless of what PA does, advance one period */
1088                     adv_bytes = min(This->period_bytes, This->held_bytes);
1089                     This->lcl_offs_bytes += adv_bytes;
1090                     This->lcl_offs_bytes %= This->real_bufsize_bytes;
1091                     This->held_bytes -= adv_bytes;
1092                 }else if(This->dataflow == eCapture){
1093                     pulse_read(This);
1094                 }
1095             }else{
1096                 This->last_time = now;
1097                 delay = This->mmdev_period_usec / 1000;
1098             }
1099         }
1100
1101         if (This->event)
1102             SetEvent(This->event);
1103
1104         TRACE("%p after update, adv usec: %d, held: %u, delay: %u\n",
1105                 This, (int)adv_usec,
1106                 (int)(This->held_bytes/ pa_frame_size(&This->ss)), delay);
1107
1108         pthread_mutex_unlock(&pulse_lock);
1109     }
1110
1111     return 0;
1112 }
1113
1114 static HRESULT pulse_stream_connect(ACImpl *This, UINT32 period_bytes) {
1115     int ret;
1116     char buffer[64];
1117     static LONG number;
1118     pa_buffer_attr attr;
1119     if (This->stream) {
1120         pa_stream_disconnect(This->stream);
1121         while (pa_stream_get_state(This->stream) == PA_STREAM_READY)
1122             pthread_cond_wait(&pulse_cond, &pulse_lock);
1123         pa_stream_unref(This->stream);
1124     }
1125     ret = InterlockedIncrement(&number);
1126     sprintf(buffer, "audio stream #%i", ret);
1127     This->stream = pa_stream_new(pulse_ctx, buffer, &This->ss, &This->map);
1128
1129     if (!This->stream) {
1130         WARN("pa_stream_new returned error %i\n", pa_context_errno(pulse_ctx));
1131         return AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1132     }
1133
1134     pa_stream_set_state_callback(This->stream, pulse_stream_state, This);
1135     pa_stream_set_buffer_attr_callback(This->stream, pulse_attr_update, This);
1136     pa_stream_set_moved_callback(This->stream, pulse_attr_update, This);
1137
1138     /* PulseAudio will fill in correct values */
1139     attr.minreq = attr.fragsize = period_bytes;
1140     attr.tlength = period_bytes * 3;
1141     attr.maxlength = This->bufsize_frames * pa_frame_size(&This->ss);
1142     attr.prebuf = pa_frame_size(&This->ss);
1143     dump_attr(&attr);
1144     if (This->dataflow == eRender)
1145         ret = pa_stream_connect_playback(This->stream, NULL, &attr,
1146         PA_STREAM_START_CORKED|PA_STREAM_START_UNMUTED|PA_STREAM_ADJUST_LATENCY, NULL, NULL);
1147     else
1148         ret = pa_stream_connect_record(This->stream, NULL, &attr,
1149         PA_STREAM_START_CORKED|PA_STREAM_START_UNMUTED|PA_STREAM_ADJUST_LATENCY);
1150     if (ret < 0) {
1151         WARN("Returns %i\n", ret);
1152         return AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1153     }
1154     while (pa_stream_get_state(This->stream) == PA_STREAM_CREATING)
1155         pthread_cond_wait(&pulse_cond, &pulse_lock);
1156     if (pa_stream_get_state(This->stream) != PA_STREAM_READY)
1157         return AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1158
1159     if (This->dataflow == eRender) {
1160         pa_stream_set_underflow_callback(This->stream, pulse_underflow_callback, This);
1161         pa_stream_set_started_callback(This->stream, pulse_started_callback, This);
1162     }
1163     return S_OK;
1164 }
1165
1166 HRESULT WINAPI AUDDRV_GetEndpointIDs(EDataFlow flow, const WCHAR ***ids, GUID **keys,
1167         UINT *num, UINT *def_index)
1168 {
1169     WCHAR *id;
1170
1171     TRACE("%d %p %p %p\n", flow, ids, num, def_index);
1172
1173     *num = 1;
1174     *def_index = 0;
1175
1176     *ids = HeapAlloc(GetProcessHeap(), 0, sizeof(**ids));
1177     *keys = NULL;
1178     if (!*ids)
1179         return E_OUTOFMEMORY;
1180
1181     (*ids)[0] = id = HeapAlloc(GetProcessHeap(), 0, sizeof(defaultW));
1182     *keys = HeapAlloc(GetProcessHeap(), 0, sizeof(**keys));
1183     if (!*keys || !id) {
1184         HeapFree(GetProcessHeap(), 0, id);
1185         HeapFree(GetProcessHeap(), 0, *keys);
1186         HeapFree(GetProcessHeap(), 0, *ids);
1187         *ids = NULL;
1188         *keys = NULL;
1189         return E_OUTOFMEMORY;
1190     }
1191     memcpy(id, defaultW, sizeof(defaultW));
1192
1193     if (flow == eRender)
1194         (*keys)[0] = pulse_render_guid;
1195     else
1196         (*keys)[0] = pulse_capture_guid;
1197
1198     return S_OK;
1199 }
1200
1201 int WINAPI AUDDRV_GetPriority(void)
1202 {
1203     HRESULT hr;
1204     pthread_mutex_lock(&pulse_lock);
1205     hr = pulse_test_connect();
1206     pthread_mutex_unlock(&pulse_lock);
1207     return SUCCEEDED(hr) ? Priority_Preferred : Priority_Unavailable;
1208 }
1209
1210 HRESULT WINAPI AUDDRV_GetAudioEndpoint(GUID *guid, IMMDevice *dev, IAudioClient **out)
1211 {
1212     ACImpl *This;
1213     int i;
1214     EDataFlow dataflow;
1215     HRESULT hr;
1216
1217     TRACE("%s %p %p\n", debugstr_guid(guid), dev, out);
1218     if (IsEqualGUID(guid, &pulse_render_guid))
1219         dataflow = eRender;
1220     else if (IsEqualGUID(guid, &pulse_capture_guid))
1221         dataflow = eCapture;
1222     else
1223         return E_UNEXPECTED;
1224
1225     *out = NULL;
1226
1227     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
1228     if (!This)
1229         return E_OUTOFMEMORY;
1230
1231     This->IAudioClient3_iface.lpVtbl = &AudioClient3_Vtbl;
1232     This->IAudioRenderClient_iface.lpVtbl = &AudioRenderClient_Vtbl;
1233     This->IAudioCaptureClient_iface.lpVtbl = &AudioCaptureClient_Vtbl;
1234     This->IAudioClock_iface.lpVtbl = &AudioClock_Vtbl;
1235     This->IAudioClock2_iface.lpVtbl = &AudioClock2_Vtbl;
1236     This->IAudioStreamVolume_iface.lpVtbl = &AudioStreamVolume_Vtbl;
1237     This->dataflow = dataflow;
1238     This->parent = dev;
1239     for (i = 0; i < PA_CHANNELS_MAX; ++i)
1240         This->vol[i] = 1.f;
1241
1242     hr = CoCreateFreeThreadedMarshaler((IUnknown*)&This->IAudioClient3_iface, &This->marshal);
1243     if (hr) {
1244         HeapFree(GetProcessHeap(), 0, This);
1245         return hr;
1246     }
1247     IMMDevice_AddRef(This->parent);
1248
1249     *out = (IAudioClient *)&This->IAudioClient3_iface;
1250     IAudioClient3_AddRef(&This->IAudioClient3_iface);
1251
1252     return S_OK;
1253 }
1254
1255 static HRESULT WINAPI AudioClient_QueryInterface(IAudioClient3 *iface,
1256         REFIID riid, void **ppv)
1257 {
1258     ACImpl *This = impl_from_IAudioClient3(iface);
1259
1260     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1261
1262     if (!ppv)
1263         return E_POINTER;
1264
1265     *ppv = NULL;
1266     if (IsEqualIID(riid, &IID_IUnknown) ||
1267             IsEqualIID(riid, &IID_IAudioClient) ||
1268             IsEqualIID(riid, &IID_IAudioClient2) ||
1269             IsEqualIID(riid, &IID_IAudioClient3))
1270         *ppv = iface;
1271     if (*ppv) {
1272         IUnknown_AddRef((IUnknown*)*ppv);
1273         return S_OK;
1274     }
1275
1276     if (IsEqualIID(riid, &IID_IMarshal))
1277         return IUnknown_QueryInterface(This->marshal, riid, ppv);
1278
1279     WARN("Unknown interface %s\n", debugstr_guid(riid));
1280     return E_NOINTERFACE;
1281 }
1282
1283 static ULONG WINAPI AudioClient_AddRef(IAudioClient3 *iface)
1284 {
1285     ACImpl *This = impl_from_IAudioClient3(iface);
1286     ULONG ref;
1287     ref = InterlockedIncrement(&This->ref);
1288     TRACE("(%p) Refcount now %u\n", This, ref);
1289     return ref;
1290 }
1291
1292 static ULONG WINAPI AudioClient_Release(IAudioClient3 *iface)
1293 {
1294     ACImpl *This = impl_from_IAudioClient3(iface);
1295     ULONG ref;
1296     ref = InterlockedDecrement(&This->ref);
1297     TRACE("(%p) Refcount now %u\n", This, ref);
1298     if (!ref) {
1299         if (This->stream) {
1300             if(This->timer){
1301                 This->please_quit = TRUE;
1302                 WaitForSingleObject(This->timer, INFINITE);
1303                 CloseHandle(This->timer);
1304             }
1305             pthread_mutex_lock(&pulse_lock);
1306             if (PA_STREAM_IS_GOOD(pa_stream_get_state(This->stream))) {
1307                 pa_stream_disconnect(This->stream);
1308                 while (PA_STREAM_IS_GOOD(pa_stream_get_state(This->stream)))
1309                     pthread_cond_wait(&pulse_cond, &pulse_lock);
1310             }
1311             pa_stream_unref(This->stream);
1312             This->stream = NULL;
1313             list_remove(&This->entry);
1314             pthread_mutex_unlock(&pulse_lock);
1315         }
1316         IUnknown_Release(This->marshal);
1317         IMMDevice_Release(This->parent);
1318         HeapFree(GetProcessHeap(), 0, This->tmp_buffer);
1319         HeapFree(GetProcessHeap(), 0, This->peek_buffer);
1320         HeapFree(GetProcessHeap(), 0, This->local_buffer);
1321         HeapFree(GetProcessHeap(), 0, This);
1322     }
1323     return ref;
1324 }
1325
1326 static void dump_fmt(const WAVEFORMATEX *fmt)
1327 {
1328     TRACE("wFormatTag: 0x%x (", fmt->wFormatTag);
1329     switch(fmt->wFormatTag) {
1330     case WAVE_FORMAT_PCM:
1331         TRACE("WAVE_FORMAT_PCM");
1332         break;
1333     case WAVE_FORMAT_IEEE_FLOAT:
1334         TRACE("WAVE_FORMAT_IEEE_FLOAT");
1335         break;
1336     case WAVE_FORMAT_EXTENSIBLE:
1337         TRACE("WAVE_FORMAT_EXTENSIBLE");
1338         break;
1339     default:
1340         TRACE("Unknown");
1341         break;
1342     }
1343     TRACE(")\n");
1344
1345     TRACE("nChannels: %u\n", fmt->nChannels);
1346     TRACE("nSamplesPerSec: %u\n", fmt->nSamplesPerSec);
1347     TRACE("nAvgBytesPerSec: %u\n", fmt->nAvgBytesPerSec);
1348     TRACE("nBlockAlign: %u\n", fmt->nBlockAlign);
1349     TRACE("wBitsPerSample: %u\n", fmt->wBitsPerSample);
1350     TRACE("cbSize: %u\n", fmt->cbSize);
1351
1352     if (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE) {
1353         WAVEFORMATEXTENSIBLE *fmtex = (void*)fmt;
1354         TRACE("dwChannelMask: %08x\n", fmtex->dwChannelMask);
1355         TRACE("Samples: %04x\n", fmtex->Samples.wReserved);
1356         TRACE("SubFormat: %s\n", wine_dbgstr_guid(&fmtex->SubFormat));
1357     }
1358 }
1359
1360 static WAVEFORMATEX *clone_format(const WAVEFORMATEX *fmt)
1361 {
1362     WAVEFORMATEX *ret;
1363     size_t size;
1364
1365     if (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
1366         size = sizeof(WAVEFORMATEXTENSIBLE);
1367     else
1368         size = sizeof(WAVEFORMATEX);
1369
1370     ret = CoTaskMemAlloc(size);
1371     if (!ret)
1372         return NULL;
1373
1374     memcpy(ret, fmt, size);
1375
1376     ret->cbSize = size - sizeof(WAVEFORMATEX);
1377
1378     return ret;
1379 }
1380
1381 static DWORD get_channel_mask(unsigned int channels)
1382 {
1383     switch(channels) {
1384     case 0:
1385         return 0;
1386     case 1:
1387         return KSAUDIO_SPEAKER_MONO;
1388     case 2:
1389         return KSAUDIO_SPEAKER_STEREO;
1390     case 3:
1391         return KSAUDIO_SPEAKER_STEREO | SPEAKER_LOW_FREQUENCY;
1392     case 4:
1393         return KSAUDIO_SPEAKER_QUAD;    /* not _SURROUND */
1394     case 5:
1395         return KSAUDIO_SPEAKER_QUAD | SPEAKER_LOW_FREQUENCY;
1396     case 6:
1397         return KSAUDIO_SPEAKER_5POINT1; /* not 5POINT1_SURROUND */
1398     case 7:
1399         return KSAUDIO_SPEAKER_5POINT1 | SPEAKER_BACK_CENTER;
1400     case 8:
1401         return KSAUDIO_SPEAKER_7POINT1_SURROUND; /* Vista deprecates 7POINT1 */
1402     }
1403     FIXME("Unknown speaker configuration: %u\n", channels);
1404     return 0;
1405 }
1406
1407 static void session_init_vols(AudioSession *session, UINT channels)
1408 {
1409     if (session->channel_count < channels) {
1410         UINT i;
1411
1412         if (session->channel_vols)
1413             session->channel_vols = HeapReAlloc(GetProcessHeap(), 0,
1414                     session->channel_vols, sizeof(float) * channels);
1415         else
1416             session->channel_vols = HeapAlloc(GetProcessHeap(), 0,
1417                     sizeof(float) * channels);
1418         if (!session->channel_vols)
1419             return;
1420
1421         for(i = session->channel_count; i < channels; ++i)
1422             session->channel_vols[i] = 1.f;
1423
1424         session->channel_count = channels;
1425     }
1426 }
1427
1428 static AudioSession *create_session(const GUID *guid, IMMDevice *device,
1429         UINT num_channels)
1430 {
1431     AudioSession *ret;
1432
1433     ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(AudioSession));
1434     if (!ret)
1435         return NULL;
1436
1437     memcpy(&ret->guid, guid, sizeof(GUID));
1438
1439     ret->device = device;
1440
1441     list_init(&ret->clients);
1442
1443     list_add_head(&g_sessions, &ret->entry);
1444
1445     session_init_vols(ret, num_channels);
1446
1447     ret->master_vol = 1.f;
1448
1449     return ret;
1450 }
1451
1452 /* if channels == 0, then this will return or create a session with
1453  * matching dataflow and GUID. otherwise, channels must also match */
1454 static HRESULT get_audio_session(const GUID *sessionguid,
1455         IMMDevice *device, UINT channels, AudioSession **out)
1456 {
1457     AudioSession *session;
1458
1459     if (!sessionguid || IsEqualGUID(sessionguid, &GUID_NULL)) {
1460         *out = create_session(&GUID_NULL, device, channels);
1461         if (!*out)
1462             return E_OUTOFMEMORY;
1463
1464         return S_OK;
1465     }
1466
1467     *out = NULL;
1468     LIST_FOR_EACH_ENTRY(session, &g_sessions, AudioSession, entry) {
1469         if (session->device == device &&
1470             IsEqualGUID(sessionguid, &session->guid)) {
1471             session_init_vols(session, channels);
1472             *out = session;
1473             break;
1474         }
1475     }
1476
1477     if (!*out) {
1478         *out = create_session(sessionguid, device, channels);
1479         if (!*out)
1480             return E_OUTOFMEMORY;
1481     }
1482
1483     return S_OK;
1484 }
1485
1486 static HRESULT pulse_spec_from_waveformat(ACImpl *This, const WAVEFORMATEX *fmt)
1487 {
1488     pa_channel_map_init(&This->map);
1489     This->ss.rate = fmt->nSamplesPerSec;
1490     This->ss.format = PA_SAMPLE_INVALID;
1491
1492     switch(fmt->wFormatTag) {
1493     case WAVE_FORMAT_IEEE_FLOAT:
1494         if (!fmt->nChannels || fmt->nChannels > 2 || fmt->wBitsPerSample != 32)
1495             break;
1496         This->ss.format = PA_SAMPLE_FLOAT32LE;
1497         pa_channel_map_init_auto(&This->map, fmt->nChannels, PA_CHANNEL_MAP_ALSA);
1498         break;
1499     case WAVE_FORMAT_PCM:
1500         if (!fmt->nChannels || fmt->nChannels > 2)
1501             break;
1502         if (fmt->wBitsPerSample == 8)
1503             This->ss.format = PA_SAMPLE_U8;
1504         else if (fmt->wBitsPerSample == 16)
1505             This->ss.format = PA_SAMPLE_S16LE;
1506         else
1507             return AUDCLNT_E_UNSUPPORTED_FORMAT;
1508         pa_channel_map_init_auto(&This->map, fmt->nChannels, PA_CHANNEL_MAP_ALSA);
1509         break;
1510     case WAVE_FORMAT_EXTENSIBLE: {
1511         WAVEFORMATEXTENSIBLE *wfe = (WAVEFORMATEXTENSIBLE*)fmt;
1512         DWORD mask = wfe->dwChannelMask;
1513         DWORD i = 0, j;
1514         if (fmt->cbSize != (sizeof(*wfe) - sizeof(*fmt)) && fmt->cbSize != sizeof(*wfe))
1515             break;
1516         if (IsEqualGUID(&wfe->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT) &&
1517             (!wfe->Samples.wValidBitsPerSample || wfe->Samples.wValidBitsPerSample == 32) &&
1518             fmt->wBitsPerSample == 32)
1519             This->ss.format = PA_SAMPLE_FLOAT32LE;
1520         else if (IsEqualGUID(&wfe->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM)) {
1521             DWORD valid = wfe->Samples.wValidBitsPerSample;
1522             if (!valid)
1523                 valid = fmt->wBitsPerSample;
1524             if (!valid || valid > fmt->wBitsPerSample)
1525                 break;
1526             switch (fmt->wBitsPerSample) {
1527                 case 8:
1528                     if (valid == 8)
1529                         This->ss.format = PA_SAMPLE_U8;
1530                     break;
1531                 case 16:
1532                     if (valid == 16)
1533                         This->ss.format = PA_SAMPLE_S16LE;
1534                     break;
1535                 case 24:
1536                     if (valid == 24)
1537                         This->ss.format = PA_SAMPLE_S24LE;
1538                     break;
1539                 case 32:
1540                     if (valid == 24)
1541                         This->ss.format = PA_SAMPLE_S24_32LE;
1542                     else if (valid == 32)
1543                         This->ss.format = PA_SAMPLE_S32LE;
1544                     break;
1545                 default:
1546                     return AUDCLNT_E_UNSUPPORTED_FORMAT;
1547             }
1548         }
1549         This->map.channels = fmt->nChannels;
1550         if (!mask || (mask & (SPEAKER_ALL|SPEAKER_RESERVED)))
1551             mask = get_channel_mask(fmt->nChannels);
1552         for (j = 0; j < ARRAY_SIZE(pulse_pos_from_wfx) && i < fmt->nChannels; ++j) {
1553             if (mask & (1 << j))
1554                 This->map.map[i++] = pulse_pos_from_wfx[j];
1555         }
1556
1557         /* Special case for mono since pulse appears to map it differently */
1558         if (mask == SPEAKER_FRONT_CENTER)
1559             This->map.map[0] = PA_CHANNEL_POSITION_MONO;
1560
1561         if (i < fmt->nChannels || (mask & SPEAKER_RESERVED)) {
1562             This->map.channels = 0;
1563             ERR("Invalid channel mask: %i/%i and %x(%x)\n", i, fmt->nChannels, mask, wfe->dwChannelMask);
1564             break;
1565         }
1566         break;
1567         }
1568     case WAVE_FORMAT_ALAW:
1569     case WAVE_FORMAT_MULAW:
1570         if (fmt->wBitsPerSample != 8) {
1571             FIXME("Unsupported bpp %u for LAW\n", fmt->wBitsPerSample);
1572             return AUDCLNT_E_UNSUPPORTED_FORMAT;
1573         }
1574         if (fmt->nChannels != 1 && fmt->nChannels != 2) {
1575             FIXME("Unsupported channels %u for LAW\n", fmt->nChannels);
1576             return AUDCLNT_E_UNSUPPORTED_FORMAT;
1577         }
1578         This->ss.format = fmt->wFormatTag == WAVE_FORMAT_MULAW ? PA_SAMPLE_ULAW : PA_SAMPLE_ALAW;
1579         pa_channel_map_init_auto(&This->map, fmt->nChannels, PA_CHANNEL_MAP_ALSA);
1580         break;
1581     default:
1582         WARN("Unhandled tag %x\n", fmt->wFormatTag);
1583         return AUDCLNT_E_UNSUPPORTED_FORMAT;
1584     }
1585     This->ss.channels = This->map.channels;
1586     if (!pa_channel_map_valid(&This->map) || This->ss.format == PA_SAMPLE_INVALID) {
1587         ERR("Invalid format! Channel spec valid: %i, format: %i\n", pa_channel_map_valid(&This->map), This->ss.format);
1588         return AUDCLNT_E_UNSUPPORTED_FORMAT;
1589     }
1590     return S_OK;
1591 }
1592
1593 static HRESULT WINAPI AudioClient_Initialize(IAudioClient3 *iface,
1594         AUDCLNT_SHAREMODE mode, DWORD flags, REFERENCE_TIME duration,
1595         REFERENCE_TIME period, const WAVEFORMATEX *fmt,
1596         const GUID *sessionguid)
1597 {
1598     ACImpl *This = impl_from_IAudioClient3(iface);
1599     HRESULT hr = S_OK;
1600     UINT32 bufsize_bytes;
1601
1602     TRACE("(%p)->(%x, %x, %s, %s, %p, %s)\n", This, mode, flags,
1603           wine_dbgstr_longlong(duration), wine_dbgstr_longlong(period), fmt, debugstr_guid(sessionguid));
1604
1605     if (!fmt)
1606         return E_POINTER;
1607
1608     if (mode != AUDCLNT_SHAREMODE_SHARED && mode != AUDCLNT_SHAREMODE_EXCLUSIVE)
1609         return E_INVALIDARG;
1610     if (mode == AUDCLNT_SHAREMODE_EXCLUSIVE)
1611         return AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED;
1612
1613     if (flags & ~(AUDCLNT_STREAMFLAGS_CROSSPROCESS |
1614                 AUDCLNT_STREAMFLAGS_LOOPBACK |
1615                 AUDCLNT_STREAMFLAGS_EVENTCALLBACK |
1616                 AUDCLNT_STREAMFLAGS_NOPERSIST |
1617                 AUDCLNT_STREAMFLAGS_RATEADJUST |
1618                 AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED |
1619                 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE |
1620                 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED |
1621                 AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY |
1622                 AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM)) {
1623         FIXME("Unknown flags: %08x\n", flags);
1624         return E_INVALIDARG;
1625     }
1626
1627     pthread_mutex_lock(&pulse_lock);
1628
1629     hr = pulse_connect();
1630     if (FAILED(hr)) {
1631         pthread_mutex_unlock(&pulse_lock);
1632         return hr;
1633     }
1634
1635     if (This->stream) {
1636         pthread_mutex_unlock(&pulse_lock);
1637         return AUDCLNT_E_ALREADY_INITIALIZED;
1638     }
1639
1640     hr = pulse_spec_from_waveformat(This, fmt);
1641     TRACE("Obtaining format returns %08x\n", hr);
1642     dump_fmt(fmt);
1643
1644     if (FAILED(hr))
1645         goto exit;
1646
1647     period = pulse_def_period[This->dataflow == eCapture];
1648     if (duration < 3 * period)
1649         duration = 3 * period;
1650
1651     This->period_bytes = pa_frame_size(&This->ss) * MulDiv(period, This->ss.rate, 10000000);
1652
1653     This->bufsize_frames = ceil((duration / 10000000.) * fmt->nSamplesPerSec);
1654     bufsize_bytes = This->bufsize_frames * pa_frame_size(&This->ss);
1655     This->mmdev_period_usec = period / 10;
1656
1657     This->share = mode;
1658     This->flags = flags;
1659     hr = pulse_stream_connect(This, This->period_bytes);
1660     if (SUCCEEDED(hr)) {
1661         UINT32 unalign;
1662         const pa_buffer_attr *attr = pa_stream_get_buffer_attr(This->stream);
1663         This->attr = *attr;
1664         /* Update frames according to new size */
1665         dump_attr(attr);
1666         if (This->dataflow == eRender) {
1667             This->real_bufsize_bytes = This->bufsize_frames * 2 * pa_frame_size(&This->ss);
1668             This->local_buffer = HeapAlloc(GetProcessHeap(), 0, This->real_bufsize_bytes);
1669             if(!This->local_buffer)
1670                 hr = E_OUTOFMEMORY;
1671         } else {
1672             UINT32 i, capture_packets;
1673
1674             if ((unalign = bufsize_bytes % This->period_bytes))
1675                 bufsize_bytes += This->period_bytes - unalign;
1676             This->bufsize_frames = bufsize_bytes / pa_frame_size(&This->ss);
1677             This->real_bufsize_bytes = bufsize_bytes;
1678
1679             capture_packets = This->real_bufsize_bytes / This->period_bytes;
1680
1681             This->local_buffer = HeapAlloc(GetProcessHeap(), 0, This->real_bufsize_bytes + capture_packets * sizeof(ACPacket));
1682             if (!This->local_buffer)
1683                 hr = E_OUTOFMEMORY;
1684             else {
1685                 ACPacket *cur_packet = (ACPacket*)((char*)This->local_buffer + This->real_bufsize_bytes);
1686                 BYTE *data = This->local_buffer;
1687                 silence_buffer(This->ss.format, This->local_buffer, This->real_bufsize_bytes);
1688                 list_init(&This->packet_free_head);
1689                 list_init(&This->packet_filled_head);
1690                 for (i = 0; i < capture_packets; ++i, ++cur_packet) {
1691                     list_add_tail(&This->packet_free_head, &cur_packet->entry);
1692                     cur_packet->data = data;
1693                     data += This->period_bytes;
1694                 }
1695             }
1696         }
1697     }
1698     if (SUCCEEDED(hr))
1699         hr = get_audio_session(sessionguid, This->parent, fmt->nChannels, &This->session);
1700     if (SUCCEEDED(hr))
1701         list_add_tail(&This->session->clients, &This->entry);
1702
1703 exit:
1704     if (FAILED(hr)) {
1705         HeapFree(GetProcessHeap(), 0, This->local_buffer);
1706         This->local_buffer = NULL;
1707         if (This->stream) {
1708             pa_stream_disconnect(This->stream);
1709             pa_stream_unref(This->stream);
1710             This->stream = NULL;
1711         }
1712     }
1713     pthread_mutex_unlock(&pulse_lock);
1714     return hr;
1715 }
1716
1717 static HRESULT WINAPI AudioClient_GetBufferSize(IAudioClient3 *iface,
1718         UINT32 *out)
1719 {
1720     ACImpl *This = impl_from_IAudioClient3(iface);
1721     HRESULT hr;
1722
1723     TRACE("(%p)->(%p)\n", This, out);
1724
1725     if (!out)
1726         return E_POINTER;
1727
1728     pthread_mutex_lock(&pulse_lock);
1729     hr = pulse_stream_valid(This);
1730     if (SUCCEEDED(hr))
1731         *out = This->bufsize_frames;
1732     pthread_mutex_unlock(&pulse_lock);
1733
1734     return hr;
1735 }
1736
1737 static HRESULT WINAPI AudioClient_GetStreamLatency(IAudioClient3 *iface,
1738         REFERENCE_TIME *latency)
1739 {
1740     ACImpl *This = impl_from_IAudioClient3(iface);
1741     const pa_buffer_attr *attr;
1742     REFERENCE_TIME lat;
1743     HRESULT hr;
1744
1745     TRACE("(%p)->(%p)\n", This, latency);
1746
1747     if (!latency)
1748         return E_POINTER;
1749
1750     pthread_mutex_lock(&pulse_lock);
1751     hr = pulse_stream_valid(This);
1752     if (FAILED(hr)) {
1753         pthread_mutex_unlock(&pulse_lock);
1754         return hr;
1755     }
1756     attr = pa_stream_get_buffer_attr(This->stream);
1757     if (This->dataflow == eRender){
1758         lat = attr->minreq / pa_frame_size(&This->ss);
1759     }else
1760         lat = attr->fragsize / pa_frame_size(&This->ss);
1761     *latency = 10000000;
1762     *latency *= lat;
1763     *latency /= This->ss.rate;
1764     *latency += pulse_def_period[0];
1765     pthread_mutex_unlock(&pulse_lock);
1766     TRACE("Latency: %u ms\n", (DWORD)(*latency / 10000));
1767     return S_OK;
1768 }
1769
1770 static void ACImpl_GetRenderPad(ACImpl *This, UINT32 *out)
1771 {
1772     *out = This->held_bytes / pa_frame_size(&This->ss);
1773 }
1774
1775 static void ACImpl_GetCapturePad(ACImpl *This, UINT32 *out)
1776 {
1777     ACPacket *packet = This->locked_ptr;
1778     if (!packet && !list_empty(&This->packet_filled_head)) {
1779         packet = (ACPacket*)list_head(&This->packet_filled_head);
1780         This->locked_ptr = packet;
1781         list_remove(&packet->entry);
1782     }
1783     if (out)
1784         *out = This->held_bytes / pa_frame_size(&This->ss);
1785 }
1786
1787 static HRESULT WINAPI AudioClient_GetCurrentPadding(IAudioClient3 *iface,
1788         UINT32 *out)
1789 {
1790     ACImpl *This = impl_from_IAudioClient3(iface);
1791     HRESULT hr;
1792
1793     TRACE("(%p)->(%p)\n", This, out);
1794
1795     if (!out)
1796         return E_POINTER;
1797
1798     pthread_mutex_lock(&pulse_lock);
1799     hr = pulse_stream_valid(This);
1800     if (FAILED(hr)) {
1801         pthread_mutex_unlock(&pulse_lock);
1802         return hr;
1803     }
1804
1805     if (This->dataflow == eRender)
1806         ACImpl_GetRenderPad(This, out);
1807     else
1808         ACImpl_GetCapturePad(This, out);
1809     pthread_mutex_unlock(&pulse_lock);
1810
1811     TRACE("%p Pad: %u ms (%u)\n", This, MulDiv(*out, 1000, This->ss.rate), *out);
1812     return S_OK;
1813 }
1814
1815 static HRESULT WINAPI AudioClient_IsFormatSupported(IAudioClient3 *iface,
1816         AUDCLNT_SHAREMODE mode, const WAVEFORMATEX *fmt,
1817         WAVEFORMATEX **out)
1818 {
1819     ACImpl *This = impl_from_IAudioClient3(iface);
1820     HRESULT hr = S_OK;
1821     WAVEFORMATEX *closest = NULL;
1822     BOOL exclusive;
1823
1824     TRACE("(%p)->(%x, %p, %p)\n", This, mode, fmt, out);
1825
1826     if (!fmt)
1827         return E_POINTER;
1828
1829     if (out)
1830         *out = NULL;
1831
1832     if (mode == AUDCLNT_SHAREMODE_EXCLUSIVE) {
1833         exclusive = 1;
1834         out = NULL;
1835     } else if (mode == AUDCLNT_SHAREMODE_SHARED) {
1836         exclusive = 0;
1837         if (!out)
1838             return E_POINTER;
1839     } else
1840         return E_INVALIDARG;
1841
1842     if (fmt->nChannels == 0)
1843         return AUDCLNT_E_UNSUPPORTED_FORMAT;
1844
1845     closest = clone_format(fmt);
1846     if (!closest)
1847         return E_OUTOFMEMORY;
1848
1849     dump_fmt(fmt);
1850
1851     switch (fmt->wFormatTag) {
1852     case WAVE_FORMAT_EXTENSIBLE: {
1853         WAVEFORMATEXTENSIBLE *ext = (WAVEFORMATEXTENSIBLE*)closest;
1854
1855         if ((fmt->cbSize != sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX) &&
1856              fmt->cbSize != sizeof(WAVEFORMATEXTENSIBLE)) ||
1857             fmt->nBlockAlign != fmt->wBitsPerSample / 8 * fmt->nChannels ||
1858             ext->Samples.wValidBitsPerSample > fmt->wBitsPerSample ||
1859             fmt->nAvgBytesPerSec != fmt->nBlockAlign * fmt->nSamplesPerSec) {
1860             hr = E_INVALIDARG;
1861             break;
1862         }
1863
1864         if (exclusive) {
1865             UINT32 mask = 0, i, channels = 0;
1866
1867             if (!(ext->dwChannelMask & (SPEAKER_ALL | SPEAKER_RESERVED))) {
1868                 for (i = 1; !(i & SPEAKER_RESERVED); i <<= 1) {
1869                     if (i & ext->dwChannelMask) {
1870                         mask |= i;
1871                         channels++;
1872                     }
1873                 }
1874
1875                 if (channels != fmt->nChannels || (ext->dwChannelMask & ~mask)) {
1876                     hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1877                     break;
1878                 }
1879             } else {
1880                 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1881                 break;
1882             }
1883         }
1884
1885         if (IsEqualGUID(&ext->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)) {
1886             if (fmt->wBitsPerSample != 32) {
1887                 hr = E_INVALIDARG;
1888                 break;
1889             }
1890
1891             if (ext->Samples.wValidBitsPerSample != fmt->wBitsPerSample) {
1892                 hr = S_FALSE;
1893                 ext->Samples.wValidBitsPerSample = fmt->wBitsPerSample;
1894             }
1895         } else if (IsEqualGUID(&ext->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM)) {
1896             if (!fmt->wBitsPerSample || fmt->wBitsPerSample > 32 || fmt->wBitsPerSample % 8) {
1897                 hr = E_INVALIDARG;
1898                 break;
1899             }
1900
1901             if (ext->Samples.wValidBitsPerSample != fmt->wBitsPerSample &&
1902                 !(fmt->wBitsPerSample == 32 &&
1903                   ext->Samples.wValidBitsPerSample == 24)) {
1904                 hr = S_FALSE;
1905                 ext->Samples.wValidBitsPerSample = fmt->wBitsPerSample;
1906                 break;
1907             }
1908         } else {
1909             hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1910             break;
1911         }
1912
1913         break;
1914     }
1915
1916     case WAVE_FORMAT_ALAW:
1917     case WAVE_FORMAT_MULAW:
1918         if (fmt->wBitsPerSample != 8) {
1919             hr = E_INVALIDARG;
1920             break;
1921         }
1922         /* Fall-through */
1923     case WAVE_FORMAT_IEEE_FLOAT:
1924         if (fmt->wFormatTag == WAVE_FORMAT_IEEE_FLOAT && fmt->wBitsPerSample != 32) {
1925             hr = E_INVALIDARG;
1926             break;
1927         }
1928         /* Fall-through */
1929     case WAVE_FORMAT_PCM:
1930         if (fmt->wFormatTag == WAVE_FORMAT_PCM &&
1931             (!fmt->wBitsPerSample || fmt->wBitsPerSample > 32 || fmt->wBitsPerSample % 8)) {
1932             hr = E_INVALIDARG;
1933             break;
1934         }
1935
1936         if (fmt->nChannels > 2) {
1937             hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1938             break;
1939         }
1940         /*
1941          * fmt->cbSize, fmt->nBlockAlign and fmt->nAvgBytesPerSec seem to be
1942          * ignored, invalid values are happily accepted.
1943          */
1944         break;
1945     default:
1946         hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1947         break;
1948     }
1949
1950     if (exclusive && hr != S_OK) {
1951         hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1952         CoTaskMemFree(closest);
1953     } else if (hr != S_FALSE)
1954         CoTaskMemFree(closest);
1955     else
1956         *out = closest;
1957
1958     /* Winepulse does not currently support exclusive mode, if you know of an
1959      * application that uses it, I will correct this..
1960      */
1961     if (hr == S_OK && exclusive)
1962         return This->dataflow == eCapture ? AUDCLNT_E_UNSUPPORTED_FORMAT : AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED;
1963
1964     TRACE("returning: %08x %p\n", hr, out ? *out : NULL);
1965     return hr;
1966 }
1967
1968 static HRESULT WINAPI AudioClient_GetMixFormat(IAudioClient3 *iface,
1969         WAVEFORMATEX **pwfx)
1970 {
1971     ACImpl *This = impl_from_IAudioClient3(iface);
1972     WAVEFORMATEXTENSIBLE *fmt = &pulse_fmt[This->dataflow == eCapture];
1973
1974     TRACE("(%p)->(%p)\n", This, pwfx);
1975
1976     if (!pwfx)
1977         return E_POINTER;
1978
1979     *pwfx = clone_format(&fmt->Format);
1980     if (!*pwfx)
1981         return E_OUTOFMEMORY;
1982     dump_fmt(*pwfx);
1983     return S_OK;
1984 }
1985
1986 static HRESULT WINAPI AudioClient_GetDevicePeriod(IAudioClient3 *iface,
1987         REFERENCE_TIME *defperiod, REFERENCE_TIME *minperiod)
1988 {
1989     ACImpl *This = impl_from_IAudioClient3(iface);
1990
1991     TRACE("(%p)->(%p, %p)\n", This, defperiod, minperiod);
1992
1993     if (!defperiod && !minperiod)
1994         return E_POINTER;
1995
1996     if (defperiod)
1997         *defperiod = pulse_def_period[This->dataflow == eCapture];
1998     if (minperiod)
1999         *minperiod = pulse_min_period[This->dataflow == eCapture];
2000
2001     return S_OK;
2002 }
2003
2004 static HRESULT WINAPI AudioClient_Start(IAudioClient3 *iface)
2005 {
2006     ACImpl *This = impl_from_IAudioClient3(iface);
2007     HRESULT hr = S_OK;
2008     int success;
2009     pa_operation *o;
2010
2011     TRACE("(%p)\n", This);
2012
2013     pthread_mutex_lock(&pulse_lock);
2014     hr = pulse_stream_valid(This);
2015     if (FAILED(hr)) {
2016         pthread_mutex_unlock(&pulse_lock);
2017         return hr;
2018     }
2019
2020     if ((This->flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK) && !This->event) {
2021         pthread_mutex_unlock(&pulse_lock);
2022         return AUDCLNT_E_EVENTHANDLE_NOT_SET;
2023     }
2024
2025     if (This->started) {
2026         pthread_mutex_unlock(&pulse_lock);
2027         return AUDCLNT_E_NOT_STOPPED;
2028     }
2029
2030     pulse_write(This);
2031
2032     if (pa_stream_is_corked(This->stream)) {
2033         o = pa_stream_cork(This->stream, 0, pulse_op_cb, &success);
2034         if (o) {
2035             while(pa_operation_get_state(o) == PA_OPERATION_RUNNING)
2036                 pthread_cond_wait(&pulse_cond, &pulse_lock);
2037             pa_operation_unref(o);
2038         } else
2039             success = 0;
2040         if (!success)
2041             hr = E_FAIL;
2042     }
2043
2044     if (SUCCEEDED(hr)) {
2045         This->started = TRUE;
2046         This->just_started = TRUE;
2047
2048         if(!This->timer)
2049             This->timer = CreateThread(NULL, 0, pulse_timer_cb, This, 0, NULL);
2050     }
2051     pthread_mutex_unlock(&pulse_lock);
2052     return hr;
2053 }
2054
2055 static HRESULT WINAPI AudioClient_Stop(IAudioClient3 *iface)
2056 {
2057     ACImpl *This = impl_from_IAudioClient3(iface);
2058     HRESULT hr = S_OK;
2059     pa_operation *o;
2060     int success;
2061
2062     TRACE("(%p)\n", This);
2063
2064     pthread_mutex_lock(&pulse_lock);
2065     hr = pulse_stream_valid(This);
2066     if (FAILED(hr)) {
2067         pthread_mutex_unlock(&pulse_lock);
2068         return hr;
2069     }
2070
2071     if (!This->started) {
2072         pthread_mutex_unlock(&pulse_lock);
2073         return S_FALSE;
2074     }
2075
2076     if (This->dataflow == eRender) {
2077         o = pa_stream_cork(This->stream, 1, pulse_op_cb, &success);
2078         if (o) {
2079             while(pa_operation_get_state(o) == PA_OPERATION_RUNNING)
2080                 pthread_cond_wait(&pulse_cond, &pulse_lock);
2081             pa_operation_unref(o);
2082         } else
2083             success = 0;
2084         if (!success)
2085             hr = E_FAIL;
2086     }
2087     if (SUCCEEDED(hr)) {
2088         This->started = FALSE;
2089     }
2090     pthread_mutex_unlock(&pulse_lock);
2091     return hr;
2092 }
2093
2094 static HRESULT WINAPI AudioClient_Reset(IAudioClient3 *iface)
2095 {
2096     ACImpl *This = impl_from_IAudioClient3(iface);
2097     HRESULT hr = S_OK;
2098
2099     TRACE("(%p)\n", This);
2100
2101     pthread_mutex_lock(&pulse_lock);
2102     hr = pulse_stream_valid(This);
2103     if (FAILED(hr)) {
2104         pthread_mutex_unlock(&pulse_lock);
2105         return hr;
2106     }
2107
2108     if (This->started) {
2109         pthread_mutex_unlock(&pulse_lock);
2110         return AUDCLNT_E_NOT_STOPPED;
2111     }
2112
2113     if (This->locked) {
2114         pthread_mutex_unlock(&pulse_lock);
2115         return AUDCLNT_E_BUFFER_OPERATION_PENDING;
2116     }
2117
2118     if (This->dataflow == eRender) {
2119         /* If there is still data in the render buffer it needs to be removed from the server */
2120         int success = 0;
2121         if (This->held_bytes) {
2122             pa_operation *o = pa_stream_flush(This->stream, pulse_op_cb, &success);
2123             if (o) {
2124                 while(pa_operation_get_state(o) == PA_OPERATION_RUNNING)
2125                     pthread_cond_wait(&pulse_cond, &pulse_lock);
2126                 pa_operation_unref(o);
2127             }
2128         }
2129         if (success || !This->held_bytes){
2130             This->clock_lastpos = This->clock_written = 0;
2131             This->pa_offs_bytes = This->lcl_offs_bytes = This->held_bytes = This->pa_held_bytes = 0;
2132         }
2133     } else {
2134         ACPacket *p;
2135         This->clock_written += This->held_bytes;
2136         This->held_bytes = 0;
2137
2138         if ((p = This->locked_ptr)) {
2139             This->locked_ptr = NULL;
2140             list_add_tail(&This->packet_free_head, &p->entry);
2141         }
2142         list_move_tail(&This->packet_free_head, &This->packet_filled_head);
2143     }
2144     pthread_mutex_unlock(&pulse_lock);
2145
2146     return hr;
2147 }
2148
2149 static HRESULT WINAPI AudioClient_SetEventHandle(IAudioClient3 *iface,
2150         HANDLE event)
2151 {
2152     ACImpl *This = impl_from_IAudioClient3(iface);
2153     HRESULT hr;
2154
2155     TRACE("(%p)->(%p)\n", This, event);
2156
2157     if (!event)
2158         return E_INVALIDARG;
2159
2160     pthread_mutex_lock(&pulse_lock);
2161     hr = pulse_stream_valid(This);
2162     if (FAILED(hr)) {
2163         pthread_mutex_unlock(&pulse_lock);
2164         return hr;
2165     }
2166
2167     if (!(This->flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK))
2168         hr = AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED;
2169     else if (This->event)
2170         hr = HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
2171     else
2172         This->event = event;
2173     pthread_mutex_unlock(&pulse_lock);
2174     return hr;
2175 }
2176
2177 static HRESULT WINAPI AudioClient_GetService(IAudioClient3 *iface, REFIID riid,
2178         void **ppv)
2179 {
2180     ACImpl *This = impl_from_IAudioClient3(iface);
2181     HRESULT hr;
2182
2183     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
2184
2185     if (!ppv)
2186         return E_POINTER;
2187     *ppv = NULL;
2188
2189     pthread_mutex_lock(&pulse_lock);
2190     hr = pulse_stream_valid(This);
2191     pthread_mutex_unlock(&pulse_lock);
2192     if (FAILED(hr))
2193         return hr;
2194
2195     if (IsEqualIID(riid, &IID_IAudioRenderClient)) {
2196         if (This->dataflow != eRender)
2197             return AUDCLNT_E_WRONG_ENDPOINT_TYPE;
2198         *ppv = &This->IAudioRenderClient_iface;
2199     } else if (IsEqualIID(riid, &IID_IAudioCaptureClient)) {
2200         if (This->dataflow != eCapture)
2201             return AUDCLNT_E_WRONG_ENDPOINT_TYPE;
2202         *ppv = &This->IAudioCaptureClient_iface;
2203     } else if (IsEqualIID(riid, &IID_IAudioClock)) {
2204         *ppv = &This->IAudioClock_iface;
2205     } else if (IsEqualIID(riid, &IID_IAudioStreamVolume)) {
2206         *ppv = &This->IAudioStreamVolume_iface;
2207     } else if (IsEqualIID(riid, &IID_IAudioSessionControl) ||
2208                IsEqualIID(riid, &IID_IChannelAudioVolume) ||
2209                IsEqualIID(riid, &IID_ISimpleAudioVolume)) {
2210         if (!This->session_wrapper) {
2211             This->session_wrapper = AudioSessionWrapper_Create(This);
2212             if (!This->session_wrapper)
2213                 return E_OUTOFMEMORY;
2214         }
2215         if (IsEqualIID(riid, &IID_IAudioSessionControl))
2216             *ppv = &This->session_wrapper->IAudioSessionControl2_iface;
2217         else if (IsEqualIID(riid, &IID_IChannelAudioVolume))
2218             *ppv = &This->session_wrapper->IChannelAudioVolume_iface;
2219         else if (IsEqualIID(riid, &IID_ISimpleAudioVolume))
2220             *ppv = &This->session_wrapper->ISimpleAudioVolume_iface;
2221     }
2222
2223     if (*ppv) {
2224         IUnknown_AddRef((IUnknown*)*ppv);
2225         return S_OK;
2226     }
2227
2228     FIXME("stub %s\n", debugstr_guid(riid));
2229     return E_NOINTERFACE;
2230 }
2231
2232 static HRESULT WINAPI AudioClient_IsOffloadCapable(IAudioClient3 *iface,
2233         AUDIO_STREAM_CATEGORY category, BOOL *offload_capable)
2234 {
2235     ACImpl *This = impl_from_IAudioClient3(iface);
2236
2237     TRACE("(%p)->(0x%x, %p)\n", This, category, offload_capable);
2238
2239     if(!offload_capable)
2240         return E_INVALIDARG;
2241
2242     *offload_capable = FALSE;
2243
2244     return S_OK;
2245 }
2246
2247 static HRESULT WINAPI AudioClient_SetClientProperties(IAudioClient3 *iface,
2248         const AudioClientProperties *prop)
2249 {
2250     ACImpl *This = impl_from_IAudioClient3(iface);
2251     const Win8AudioClientProperties *legacy_prop = (const Win8AudioClientProperties *)prop;
2252
2253     TRACE("(%p)->(%p)\n", This, prop);
2254
2255     if(!legacy_prop)
2256         return E_POINTER;
2257
2258     if(legacy_prop->cbSize == sizeof(AudioClientProperties)){
2259         TRACE("{ bIsOffload: %u, eCategory: 0x%x, Options: 0x%x }\n",
2260                 legacy_prop->bIsOffload,
2261                 legacy_prop->eCategory,
2262                 prop->Options);
2263     }else if(legacy_prop->cbSize == sizeof(Win8AudioClientProperties)){
2264         TRACE("{ bIsOffload: %u, eCategory: 0x%x }\n",
2265                 legacy_prop->bIsOffload,
2266                 legacy_prop->eCategory);
2267     }else{
2268         WARN("Unsupported Size = %d\n", legacy_prop->cbSize);
2269         return E_INVALIDARG;
2270     }
2271
2272
2273     if(legacy_prop->bIsOffload)
2274         return AUDCLNT_E_ENDPOINT_OFFLOAD_NOT_CAPABLE;
2275
2276     return S_OK;
2277 }
2278
2279 static HRESULT WINAPI AudioClient_GetBufferSizeLimits(IAudioClient3 *iface,
2280         const WAVEFORMATEX *format, BOOL event_driven, REFERENCE_TIME *min_duration,
2281         REFERENCE_TIME *max_duration)
2282 {
2283     ACImpl *This = impl_from_IAudioClient3(iface);
2284
2285     FIXME("(%p)->(%p, %u, %p, %p)\n", This, format, event_driven, min_duration, max_duration);
2286
2287     return E_NOTIMPL;
2288 }
2289
2290 static HRESULT WINAPI AudioClient_GetSharedModeEnginePeriod(IAudioClient3 *iface,
2291         const WAVEFORMATEX *format, UINT32 *default_period_frames, UINT32 *unit_period_frames,
2292         UINT32 *min_period_frames, UINT32 *max_period_frames)
2293 {
2294     ACImpl *This = impl_from_IAudioClient3(iface);
2295
2296     FIXME("(%p)->(%p, %p, %p, %p, %p)\n", This, format, default_period_frames, unit_period_frames,
2297             min_period_frames, max_period_frames);
2298
2299     return E_NOTIMPL;
2300 }
2301
2302 static HRESULT WINAPI AudioClient_GetCurrentSharedModeEnginePeriod(IAudioClient3 *iface,
2303         WAVEFORMATEX **cur_format, UINT32 *cur_period_frames)
2304 {
2305     ACImpl *This = impl_from_IAudioClient3(iface);
2306
2307     FIXME("(%p)->(%p, %p)\n", This, cur_format, cur_period_frames);
2308
2309     return E_NOTIMPL;
2310 }
2311
2312 static HRESULT WINAPI AudioClient_InitializeSharedAudioStream(IAudioClient3 *iface,
2313         DWORD flags, UINT32 period_frames, const WAVEFORMATEX *format,
2314         const GUID *session_guid)
2315 {
2316     ACImpl *This = impl_from_IAudioClient3(iface);
2317
2318     FIXME("(%p)->(0x%x, %u, %p, %s)\n", This, flags, period_frames, format, debugstr_guid(session_guid));
2319
2320     return E_NOTIMPL;
2321 }
2322
2323 static const IAudioClient3Vtbl AudioClient3_Vtbl =
2324 {
2325     AudioClient_QueryInterface,
2326     AudioClient_AddRef,
2327     AudioClient_Release,
2328     AudioClient_Initialize,
2329     AudioClient_GetBufferSize,
2330     AudioClient_GetStreamLatency,
2331     AudioClient_GetCurrentPadding,
2332     AudioClient_IsFormatSupported,
2333     AudioClient_GetMixFormat,
2334     AudioClient_GetDevicePeriod,
2335     AudioClient_Start,
2336     AudioClient_Stop,
2337     AudioClient_Reset,
2338     AudioClient_SetEventHandle,
2339     AudioClient_GetService,
2340     AudioClient_IsOffloadCapable,
2341     AudioClient_SetClientProperties,
2342     AudioClient_GetBufferSizeLimits,
2343     AudioClient_GetSharedModeEnginePeriod,
2344     AudioClient_GetCurrentSharedModeEnginePeriod,
2345     AudioClient_InitializeSharedAudioStream,
2346 };
2347
2348 static HRESULT WINAPI AudioRenderClient_QueryInterface(
2349         IAudioRenderClient *iface, REFIID riid, void **ppv)
2350 {
2351     ACImpl *This = impl_from_IAudioRenderClient(iface);
2352     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2353
2354     if (!ppv)
2355         return E_POINTER;
2356     *ppv = NULL;
2357
2358     if (IsEqualIID(riid, &IID_IUnknown) ||
2359         IsEqualIID(riid, &IID_IAudioRenderClient))
2360         *ppv = iface;
2361     if (*ppv) {
2362         IUnknown_AddRef((IUnknown*)*ppv);
2363         return S_OK;
2364     }
2365
2366     if (IsEqualIID(riid, &IID_IMarshal))
2367         return IUnknown_QueryInterface(This->marshal, riid, ppv);
2368
2369     WARN("Unknown interface %s\n", debugstr_guid(riid));
2370     return E_NOINTERFACE;
2371 }
2372
2373 static ULONG WINAPI AudioRenderClient_AddRef(IAudioRenderClient *iface)
2374 {
2375     ACImpl *This = impl_from_IAudioRenderClient(iface);
2376     return AudioClient_AddRef(&This->IAudioClient3_iface);
2377 }
2378
2379 static ULONG WINAPI AudioRenderClient_Release(IAudioRenderClient *iface)
2380 {
2381     ACImpl *This = impl_from_IAudioRenderClient(iface);
2382     return AudioClient_Release(&This->IAudioClient3_iface);
2383 }
2384
2385 static void alloc_tmp_buffer(ACImpl *This, UINT32 bytes)
2386 {
2387     if(This->tmp_buffer_bytes >= bytes)
2388         return;
2389
2390     HeapFree(GetProcessHeap(), 0, This->tmp_buffer);
2391     This->tmp_buffer = HeapAlloc(GetProcessHeap(), 0, bytes);
2392     This->tmp_buffer_bytes = bytes;
2393 }
2394
2395 static HRESULT WINAPI AudioRenderClient_GetBuffer(IAudioRenderClient *iface,
2396         UINT32 frames, BYTE **data)
2397 {
2398     ACImpl *This = impl_from_IAudioRenderClient(iface);
2399     size_t bytes = frames * pa_frame_size(&This->ss);
2400     HRESULT hr = S_OK;
2401     UINT32 wri_offs_bytes;
2402
2403     TRACE("(%p)->(%u, %p)\n", This, frames, data);
2404
2405     if (!data)
2406         return E_POINTER;
2407     *data = NULL;
2408
2409     pthread_mutex_lock(&pulse_lock);
2410     hr = pulse_stream_valid(This);
2411     if (FAILED(hr) || This->locked) {
2412         pthread_mutex_unlock(&pulse_lock);
2413         return FAILED(hr) ? hr : AUDCLNT_E_OUT_OF_ORDER;
2414     }
2415     if (!frames) {
2416         pthread_mutex_unlock(&pulse_lock);
2417         return S_OK;
2418     }
2419
2420     if(This->held_bytes / pa_frame_size(&This->ss) + frames > This->bufsize_frames){
2421         pthread_mutex_unlock(&pulse_lock);
2422         return AUDCLNT_E_BUFFER_TOO_LARGE;
2423     }
2424
2425     wri_offs_bytes = (This->lcl_offs_bytes + This->held_bytes) % This->real_bufsize_bytes;
2426     if(wri_offs_bytes + bytes > This->real_bufsize_bytes){
2427         alloc_tmp_buffer(This, bytes);
2428         *data = This->tmp_buffer;
2429         This->locked = -bytes;
2430     }else{
2431         *data = This->local_buffer + wri_offs_bytes;
2432         This->locked = bytes;
2433     }
2434
2435     silence_buffer(This->ss.format, *data, bytes);
2436
2437     pthread_mutex_unlock(&pulse_lock);
2438
2439     return hr;
2440 }
2441
2442 static void pulse_wrap_buffer(ACImpl *This, BYTE *buffer, UINT32 written_bytes)
2443 {
2444     UINT32 wri_offs_bytes = (This->lcl_offs_bytes + This->held_bytes) % This->real_bufsize_bytes;
2445     UINT32 chunk_bytes = This->real_bufsize_bytes - wri_offs_bytes;
2446
2447     if(written_bytes <= chunk_bytes){
2448         memcpy(This->local_buffer + wri_offs_bytes, buffer, written_bytes);
2449     }else{
2450         memcpy(This->local_buffer + wri_offs_bytes, buffer, chunk_bytes);
2451         memcpy(This->local_buffer, buffer + chunk_bytes,
2452                 written_bytes - chunk_bytes);
2453     }
2454 }
2455
2456 static HRESULT WINAPI AudioRenderClient_ReleaseBuffer(
2457         IAudioRenderClient *iface, UINT32 written_frames, DWORD flags)
2458 {
2459     ACImpl *This = impl_from_IAudioRenderClient(iface);
2460     UINT32 written_bytes = written_frames * pa_frame_size(&This->ss);
2461     BYTE *buffer;
2462
2463     TRACE("(%p)->(%u, %x)\n", This, written_frames, flags);
2464
2465     pthread_mutex_lock(&pulse_lock);
2466     if (!This->locked || !written_frames) {
2467         This->locked = 0;
2468         pthread_mutex_unlock(&pulse_lock);
2469         return written_frames ? AUDCLNT_E_OUT_OF_ORDER : S_OK;
2470     }
2471
2472     if(written_frames * pa_frame_size(&This->ss) > (This->locked >= 0 ? This->locked : -This->locked)){
2473         pthread_mutex_unlock(&pulse_lock);
2474         return AUDCLNT_E_INVALID_SIZE;
2475     }
2476
2477     if(This->locked >= 0)
2478         buffer = This->local_buffer + (This->lcl_offs_bytes + This->held_bytes) % This->real_bufsize_bytes;
2479     else
2480         buffer = This->tmp_buffer;
2481
2482     if(flags & AUDCLNT_BUFFERFLAGS_SILENT)
2483         silence_buffer(This->ss.format, buffer, written_bytes);
2484
2485     if(This->locked < 0)
2486         pulse_wrap_buffer(This, buffer, written_bytes);
2487
2488     This->held_bytes += written_bytes;
2489     This->pa_held_bytes += written_bytes;
2490     if(This->pa_held_bytes > This->real_bufsize_bytes){
2491         This->pa_offs_bytes += This->pa_held_bytes - This->real_bufsize_bytes;
2492         This->pa_offs_bytes %= This->real_bufsize_bytes;
2493         This->pa_held_bytes = This->real_bufsize_bytes;
2494     }
2495     This->clock_written += written_bytes;
2496     This->locked = 0;
2497
2498     TRACE("Released %u, held %zu\n", written_frames, This->held_bytes / pa_frame_size(&This->ss));
2499
2500     pthread_mutex_unlock(&pulse_lock);
2501
2502     return S_OK;
2503 }
2504
2505 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl = {
2506     AudioRenderClient_QueryInterface,
2507     AudioRenderClient_AddRef,
2508     AudioRenderClient_Release,
2509     AudioRenderClient_GetBuffer,
2510     AudioRenderClient_ReleaseBuffer
2511 };
2512
2513 static HRESULT WINAPI AudioCaptureClient_QueryInterface(
2514         IAudioCaptureClient *iface, REFIID riid, void **ppv)
2515 {
2516     ACImpl *This = impl_from_IAudioCaptureClient(iface);
2517     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2518
2519     if (!ppv)
2520         return E_POINTER;
2521     *ppv = NULL;
2522
2523     if (IsEqualIID(riid, &IID_IUnknown) ||
2524         IsEqualIID(riid, &IID_IAudioCaptureClient))
2525         *ppv = iface;
2526     if (*ppv) {
2527         IUnknown_AddRef((IUnknown*)*ppv);
2528         return S_OK;
2529     }
2530
2531     if (IsEqualIID(riid, &IID_IMarshal))
2532         return IUnknown_QueryInterface(This->marshal, riid, ppv);
2533
2534     WARN("Unknown interface %s\n", debugstr_guid(riid));
2535     return E_NOINTERFACE;
2536 }
2537
2538 static ULONG WINAPI AudioCaptureClient_AddRef(IAudioCaptureClient *iface)
2539 {
2540     ACImpl *This = impl_from_IAudioCaptureClient(iface);
2541     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
2542 }
2543
2544 static ULONG WINAPI AudioCaptureClient_Release(IAudioCaptureClient *iface)
2545 {
2546     ACImpl *This = impl_from_IAudioCaptureClient(iface);
2547     return IAudioClient3_Release(&This->IAudioClient3_iface);
2548 }
2549
2550 static HRESULT WINAPI AudioCaptureClient_GetBuffer(IAudioCaptureClient *iface,
2551         BYTE **data, UINT32 *frames, DWORD *flags, UINT64 *devpos,
2552         UINT64 *qpcpos)
2553 {
2554     ACImpl *This = impl_from_IAudioCaptureClient(iface);
2555     HRESULT hr;
2556     ACPacket *packet;
2557
2558     TRACE("(%p)->(%p, %p, %p, %p, %p)\n", This, data, frames, flags,
2559             devpos, qpcpos);
2560
2561     if (!data)
2562        return E_POINTER;
2563
2564     *data = NULL;
2565
2566     if (!frames || !flags)
2567         return E_POINTER;
2568
2569     pthread_mutex_lock(&pulse_lock);
2570     hr = pulse_stream_valid(This);
2571     if (FAILED(hr) || This->locked) {
2572         pthread_mutex_unlock(&pulse_lock);
2573         return FAILED(hr) ? hr : AUDCLNT_E_OUT_OF_ORDER;
2574     }
2575
2576     ACImpl_GetCapturePad(This, NULL);
2577     if ((packet = This->locked_ptr)) {
2578         *frames = This->period_bytes / pa_frame_size(&This->ss);
2579         *flags = 0;
2580         if (packet->discont)
2581             *flags |= AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY;
2582         if (devpos) {
2583             if (packet->discont)
2584                 *devpos = (This->clock_written + This->period_bytes) / pa_frame_size(&This->ss);
2585             else
2586                 *devpos = This->clock_written / pa_frame_size(&This->ss);
2587         }
2588         if (qpcpos)
2589             *qpcpos = packet->qpcpos;
2590         *data = packet->data;
2591     }
2592     else
2593         *frames = 0;
2594     This->locked = *frames;
2595     pthread_mutex_unlock(&pulse_lock);
2596     return *frames ? S_OK : AUDCLNT_S_BUFFER_EMPTY;
2597 }
2598
2599 static HRESULT WINAPI AudioCaptureClient_ReleaseBuffer(
2600         IAudioCaptureClient *iface, UINT32 done)
2601 {
2602     ACImpl *This = impl_from_IAudioCaptureClient(iface);
2603
2604     TRACE("(%p)->(%u)\n", This, done);
2605
2606     pthread_mutex_lock(&pulse_lock);
2607     if (!This->locked && done) {
2608         pthread_mutex_unlock(&pulse_lock);
2609         return AUDCLNT_E_OUT_OF_ORDER;
2610     }
2611     if (done && This->locked != done) {
2612         pthread_mutex_unlock(&pulse_lock);
2613         return AUDCLNT_E_INVALID_SIZE;
2614     }
2615     if (done) {
2616         ACPacket *packet = This->locked_ptr;
2617         This->locked_ptr = NULL;
2618         This->held_bytes -= This->period_bytes;
2619         if (packet->discont)
2620             This->clock_written += 2 * This->period_bytes;
2621         else
2622             This->clock_written += This->period_bytes;
2623         list_add_tail(&This->packet_free_head, &packet->entry);
2624     }
2625     This->locked = 0;
2626     pthread_mutex_unlock(&pulse_lock);
2627     return S_OK;
2628 }
2629
2630 static HRESULT WINAPI AudioCaptureClient_GetNextPacketSize(
2631         IAudioCaptureClient *iface, UINT32 *frames)
2632 {
2633     ACImpl *This = impl_from_IAudioCaptureClient(iface);
2634
2635     TRACE("(%p)->(%p)\n", This, frames);
2636     if (!frames)
2637         return E_POINTER;
2638
2639     pthread_mutex_lock(&pulse_lock);
2640     ACImpl_GetCapturePad(This, NULL);
2641     if (This->locked_ptr)
2642         *frames = This->period_bytes / pa_frame_size(&This->ss);
2643     else
2644         *frames = 0;
2645     pthread_mutex_unlock(&pulse_lock);
2646     return S_OK;
2647 }
2648
2649 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl =
2650 {
2651     AudioCaptureClient_QueryInterface,
2652     AudioCaptureClient_AddRef,
2653     AudioCaptureClient_Release,
2654     AudioCaptureClient_GetBuffer,
2655     AudioCaptureClient_ReleaseBuffer,
2656     AudioCaptureClient_GetNextPacketSize
2657 };
2658
2659 static HRESULT WINAPI AudioClock_QueryInterface(IAudioClock *iface,
2660         REFIID riid, void **ppv)
2661 {
2662     ACImpl *This = impl_from_IAudioClock(iface);
2663
2664     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2665
2666     if (!ppv)
2667         return E_POINTER;
2668     *ppv = NULL;
2669
2670     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IAudioClock))
2671         *ppv = iface;
2672     else if (IsEqualIID(riid, &IID_IAudioClock2))
2673         *ppv = &This->IAudioClock2_iface;
2674     if (*ppv) {
2675         IUnknown_AddRef((IUnknown*)*ppv);
2676         return S_OK;
2677     }
2678
2679     if (IsEqualIID(riid, &IID_IMarshal))
2680         return IUnknown_QueryInterface(This->marshal, riid, ppv);
2681
2682     WARN("Unknown interface %s\n", debugstr_guid(riid));
2683     return E_NOINTERFACE;
2684 }
2685
2686 static ULONG WINAPI AudioClock_AddRef(IAudioClock *iface)
2687 {
2688     ACImpl *This = impl_from_IAudioClock(iface);
2689     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
2690 }
2691
2692 static ULONG WINAPI AudioClock_Release(IAudioClock *iface)
2693 {
2694     ACImpl *This = impl_from_IAudioClock(iface);
2695     return IAudioClient3_Release(&This->IAudioClient3_iface);
2696 }
2697
2698 static HRESULT WINAPI AudioClock_GetFrequency(IAudioClock *iface, UINT64 *freq)
2699 {
2700     ACImpl *This = impl_from_IAudioClock(iface);
2701     HRESULT hr;
2702
2703     TRACE("(%p)->(%p)\n", This, freq);
2704
2705     pthread_mutex_lock(&pulse_lock);
2706     hr = pulse_stream_valid(This);
2707     if (SUCCEEDED(hr)) {
2708         *freq = This->ss.rate;
2709         if (This->share == AUDCLNT_SHAREMODE_SHARED)
2710             *freq *= pa_frame_size(&This->ss);
2711     }
2712     pthread_mutex_unlock(&pulse_lock);
2713     return hr;
2714 }
2715
2716 static HRESULT WINAPI AudioClock_GetPosition(IAudioClock *iface, UINT64 *pos,
2717         UINT64 *qpctime)
2718 {
2719     ACImpl *This = impl_from_IAudioClock(iface);
2720     HRESULT hr;
2721
2722     TRACE("(%p)->(%p, %p)\n", This, pos, qpctime);
2723
2724     if (!pos)
2725         return E_POINTER;
2726
2727     pthread_mutex_lock(&pulse_lock);
2728     hr = pulse_stream_valid(This);
2729     if (FAILED(hr)) {
2730         pthread_mutex_unlock(&pulse_lock);
2731         return hr;
2732     }
2733
2734     *pos = This->clock_written - This->held_bytes;
2735
2736     if (This->share == AUDCLNT_SHAREMODE_EXCLUSIVE)
2737         *pos /= pa_frame_size(&This->ss);
2738
2739     /* Make time never go backwards */
2740     if (*pos < This->clock_lastpos)
2741         *pos = This->clock_lastpos;
2742     else
2743         This->clock_lastpos = *pos;
2744     pthread_mutex_unlock(&pulse_lock);
2745
2746     TRACE("%p Position: %u\n", This, (unsigned)*pos);
2747
2748     if (qpctime) {
2749         LARGE_INTEGER stamp, freq;
2750         QueryPerformanceCounter(&stamp);
2751         QueryPerformanceFrequency(&freq);
2752         *qpctime = (stamp.QuadPart * (INT64)10000000) / freq.QuadPart;
2753     }
2754
2755     return S_OK;
2756 }
2757
2758 static HRESULT WINAPI AudioClock_GetCharacteristics(IAudioClock *iface,
2759         DWORD *chars)
2760 {
2761     ACImpl *This = impl_from_IAudioClock(iface);
2762
2763     TRACE("(%p)->(%p)\n", This, chars);
2764
2765     if (!chars)
2766         return E_POINTER;
2767
2768     *chars = AUDIOCLOCK_CHARACTERISTIC_FIXED_FREQ;
2769
2770     return S_OK;
2771 }
2772
2773 static const IAudioClockVtbl AudioClock_Vtbl =
2774 {
2775     AudioClock_QueryInterface,
2776     AudioClock_AddRef,
2777     AudioClock_Release,
2778     AudioClock_GetFrequency,
2779     AudioClock_GetPosition,
2780     AudioClock_GetCharacteristics
2781 };
2782
2783 static HRESULT WINAPI AudioClock2_QueryInterface(IAudioClock2 *iface,
2784         REFIID riid, void **ppv)
2785 {
2786     ACImpl *This = impl_from_IAudioClock2(iface);
2787     return IAudioClock_QueryInterface(&This->IAudioClock_iface, riid, ppv);
2788 }
2789
2790 static ULONG WINAPI AudioClock2_AddRef(IAudioClock2 *iface)
2791 {
2792     ACImpl *This = impl_from_IAudioClock2(iface);
2793     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
2794 }
2795
2796 static ULONG WINAPI AudioClock2_Release(IAudioClock2 *iface)
2797 {
2798     ACImpl *This = impl_from_IAudioClock2(iface);
2799     return IAudioClient3_Release(&This->IAudioClient3_iface);
2800 }
2801
2802 static HRESULT WINAPI AudioClock2_GetDevicePosition(IAudioClock2 *iface,
2803         UINT64 *pos, UINT64 *qpctime)
2804 {
2805     ACImpl *This = impl_from_IAudioClock2(iface);
2806     HRESULT hr = AudioClock_GetPosition(&This->IAudioClock_iface, pos, qpctime);
2807     if (SUCCEEDED(hr) && This->share == AUDCLNT_SHAREMODE_SHARED)
2808         *pos /= pa_frame_size(&This->ss);
2809     return hr;
2810 }
2811
2812 static const IAudioClock2Vtbl AudioClock2_Vtbl =
2813 {
2814     AudioClock2_QueryInterface,
2815     AudioClock2_AddRef,
2816     AudioClock2_Release,
2817     AudioClock2_GetDevicePosition
2818 };
2819
2820 static HRESULT WINAPI AudioStreamVolume_QueryInterface(
2821         IAudioStreamVolume *iface, REFIID riid, void **ppv)
2822 {
2823     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2824
2825     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2826
2827     if (!ppv)
2828         return E_POINTER;
2829     *ppv = NULL;
2830
2831     if (IsEqualIID(riid, &IID_IUnknown) ||
2832         IsEqualIID(riid, &IID_IAudioStreamVolume))
2833         *ppv = iface;
2834     if (*ppv) {
2835         IUnknown_AddRef((IUnknown*)*ppv);
2836         return S_OK;
2837     }
2838
2839     if (IsEqualIID(riid, &IID_IMarshal))
2840         return IUnknown_QueryInterface(This->marshal, riid, ppv);
2841
2842     WARN("Unknown interface %s\n", debugstr_guid(riid));
2843     return E_NOINTERFACE;
2844 }
2845
2846 static ULONG WINAPI AudioStreamVolume_AddRef(IAudioStreamVolume *iface)
2847 {
2848     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2849     return IAudioClient3_AddRef(&This->IAudioClient3_iface);
2850 }
2851
2852 static ULONG WINAPI AudioStreamVolume_Release(IAudioStreamVolume *iface)
2853 {
2854     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2855     return IAudioClient3_Release(&This->IAudioClient3_iface);
2856 }
2857
2858 static HRESULT WINAPI AudioStreamVolume_GetChannelCount(
2859         IAudioStreamVolume *iface, UINT32 *out)
2860 {
2861     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2862
2863     TRACE("(%p)->(%p)\n", This, out);
2864
2865     if (!out)
2866         return E_POINTER;
2867
2868     *out = This->ss.channels;
2869
2870     return S_OK;
2871 }
2872
2873 struct pulse_info_cb_data {
2874     UINT32 n;
2875     float *levels;
2876 };
2877
2878 static HRESULT WINAPI AudioStreamVolume_SetAllVolumes(
2879         IAudioStreamVolume *iface, UINT32 count, const float *levels)
2880 {
2881     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2882     HRESULT hr;
2883     int i;
2884
2885     TRACE("(%p)->(%d, %p)\n", This, count, levels);
2886
2887     if (!levels)
2888         return E_POINTER;
2889
2890     if (count != This->ss.channels)
2891         return E_INVALIDARG;
2892
2893     pthread_mutex_lock(&pulse_lock);
2894     hr = pulse_stream_valid(This);
2895     if (FAILED(hr))
2896         goto out;
2897
2898     for (i = 0; i < count; ++i)
2899         This->vol[i] = levels[i];
2900
2901 out:
2902     pthread_mutex_unlock(&pulse_lock);
2903     return hr;
2904 }
2905
2906 static HRESULT WINAPI AudioStreamVolume_GetAllVolumes(
2907         IAudioStreamVolume *iface, UINT32 count, float *levels)
2908 {
2909     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2910     HRESULT hr;
2911     int i;
2912
2913     TRACE("(%p)->(%d, %p)\n", This, count, levels);
2914
2915     if (!levels)
2916         return E_POINTER;
2917
2918     if (count != This->ss.channels)
2919         return E_INVALIDARG;
2920
2921     pthread_mutex_lock(&pulse_lock);
2922     hr = pulse_stream_valid(This);
2923     if (FAILED(hr))
2924         goto out;
2925
2926     for (i = 0; i < count; ++i)
2927         levels[i] = This->vol[i];
2928
2929 out:
2930     pthread_mutex_unlock(&pulse_lock);
2931     return hr;
2932 }
2933
2934 static HRESULT WINAPI AudioStreamVolume_SetChannelVolume(
2935         IAudioStreamVolume *iface, UINT32 index, float level)
2936 {
2937     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2938     HRESULT hr;
2939     float volumes[PA_CHANNELS_MAX];
2940
2941     TRACE("(%p)->(%d, %f)\n", This, index, level);
2942
2943     if (level < 0.f || level > 1.f)
2944         return E_INVALIDARG;
2945
2946     if (index >= This->ss.channels)
2947         return E_INVALIDARG;
2948
2949     hr = AudioStreamVolume_GetAllVolumes(iface, This->ss.channels, volumes);
2950     volumes[index] = level;
2951     if (SUCCEEDED(hr))
2952         hr = AudioStreamVolume_SetAllVolumes(iface, This->ss.channels, volumes);
2953     return hr;
2954 }
2955
2956 static HRESULT WINAPI AudioStreamVolume_GetChannelVolume(
2957         IAudioStreamVolume *iface, UINT32 index, float *level)
2958 {
2959     ACImpl *This = impl_from_IAudioStreamVolume(iface);
2960     float volumes[PA_CHANNELS_MAX];
2961     HRESULT hr;
2962
2963     TRACE("(%p)->(%d, %p)\n", This, index, level);
2964
2965     if (!level)
2966         return E_POINTER;
2967
2968     if (index >= This->ss.channels)
2969         return E_INVALIDARG;
2970
2971     hr = AudioStreamVolume_GetAllVolumes(iface, This->ss.channels, volumes);
2972     if (SUCCEEDED(hr))
2973         *level = volumes[index];
2974     return hr;
2975 }
2976
2977 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl =
2978 {
2979     AudioStreamVolume_QueryInterface,
2980     AudioStreamVolume_AddRef,
2981     AudioStreamVolume_Release,
2982     AudioStreamVolume_GetChannelCount,
2983     AudioStreamVolume_SetChannelVolume,
2984     AudioStreamVolume_GetChannelVolume,
2985     AudioStreamVolume_SetAllVolumes,
2986     AudioStreamVolume_GetAllVolumes
2987 };
2988
2989 static AudioSessionWrapper *AudioSessionWrapper_Create(ACImpl *client)
2990 {
2991     AudioSessionWrapper *ret;
2992
2993     ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2994             sizeof(AudioSessionWrapper));
2995     if (!ret)
2996         return NULL;
2997
2998     ret->IAudioSessionControl2_iface.lpVtbl = &AudioSessionControl2_Vtbl;
2999     ret->ISimpleAudioVolume_iface.lpVtbl = &SimpleAudioVolume_Vtbl;
3000     ret->IChannelAudioVolume_iface.lpVtbl = &ChannelAudioVolume_Vtbl;
3001
3002     ret->ref = !client;
3003
3004     ret->client = client;
3005     if (client) {
3006         ret->session = client->session;
3007         AudioClient_AddRef(&client->IAudioClient3_iface);
3008     }
3009
3010     return ret;
3011 }
3012
3013 static HRESULT WINAPI AudioSessionControl_QueryInterface(
3014         IAudioSessionControl2 *iface, REFIID riid, void **ppv)
3015 {
3016     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
3017
3018     if (!ppv)
3019         return E_POINTER;
3020     *ppv = NULL;
3021
3022     if (IsEqualIID(riid, &IID_IUnknown) ||
3023         IsEqualIID(riid, &IID_IAudioSessionControl) ||
3024         IsEqualIID(riid, &IID_IAudioSessionControl2))
3025         *ppv = iface;
3026     if (*ppv) {
3027         IUnknown_AddRef((IUnknown*)*ppv);
3028         return S_OK;
3029     }
3030
3031     WARN("Unknown interface %s\n", debugstr_guid(riid));
3032     return E_NOINTERFACE;
3033 }
3034
3035 static ULONG WINAPI AudioSessionControl_AddRef(IAudioSessionControl2 *iface)
3036 {
3037     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3038     ULONG ref;
3039     ref = InterlockedIncrement(&This->ref);
3040     TRACE("(%p) Refcount now %u\n", This, ref);
3041     return ref;
3042 }
3043
3044 static ULONG WINAPI AudioSessionControl_Release(IAudioSessionControl2 *iface)
3045 {
3046     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3047     ULONG ref;
3048     ref = InterlockedDecrement(&This->ref);
3049     TRACE("(%p) Refcount now %u\n", This, ref);
3050     if (!ref) {
3051         if (This->client) {
3052             This->client->session_wrapper = NULL;
3053             AudioClient_Release(&This->client->IAudioClient3_iface);
3054         }
3055         HeapFree(GetProcessHeap(), 0, This);
3056     }
3057     return ref;
3058 }
3059
3060 static HRESULT WINAPI AudioSessionControl_GetState(IAudioSessionControl2 *iface,
3061         AudioSessionState *state)
3062 {
3063     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3064     ACImpl *client;
3065
3066     TRACE("(%p)->(%p)\n", This, state);
3067
3068     if (!state)
3069         return NULL_PTR_ERR;
3070
3071     pthread_mutex_lock(&pulse_lock);
3072     if (list_empty(&This->session->clients)) {
3073         *state = AudioSessionStateExpired;
3074         goto out;
3075     }
3076     LIST_FOR_EACH_ENTRY(client, &This->session->clients, ACImpl, entry) {
3077         if (client->started) {
3078             *state = AudioSessionStateActive;
3079             goto out;
3080         }
3081     }
3082     *state = AudioSessionStateInactive;
3083
3084 out:
3085     pthread_mutex_unlock(&pulse_lock);
3086     return S_OK;
3087 }
3088
3089 static HRESULT WINAPI AudioSessionControl_GetDisplayName(
3090         IAudioSessionControl2 *iface, WCHAR **name)
3091 {
3092     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3093
3094     FIXME("(%p)->(%p) - stub\n", This, name);
3095
3096     return E_NOTIMPL;
3097 }
3098
3099 static HRESULT WINAPI AudioSessionControl_SetDisplayName(
3100         IAudioSessionControl2 *iface, const WCHAR *name, const GUID *session)
3101 {
3102     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3103
3104     FIXME("(%p)->(%p, %s) - stub\n", This, name, debugstr_guid(session));
3105
3106     return E_NOTIMPL;
3107 }
3108
3109 static HRESULT WINAPI AudioSessionControl_GetIconPath(
3110         IAudioSessionControl2 *iface, WCHAR **path)
3111 {
3112     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3113
3114     FIXME("(%p)->(%p) - stub\n", This, path);
3115
3116     return E_NOTIMPL;
3117 }
3118
3119 static HRESULT WINAPI AudioSessionControl_SetIconPath(
3120         IAudioSessionControl2 *iface, const WCHAR *path, const GUID *session)
3121 {
3122     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3123
3124     FIXME("(%p)->(%p, %s) - stub\n", This, path, debugstr_guid(session));
3125
3126     return E_NOTIMPL;
3127 }
3128
3129 static HRESULT WINAPI AudioSessionControl_GetGroupingParam(
3130         IAudioSessionControl2 *iface, GUID *group)
3131 {
3132     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3133
3134     FIXME("(%p)->(%p) - stub\n", This, group);
3135
3136     return E_NOTIMPL;
3137 }
3138
3139 static HRESULT WINAPI AudioSessionControl_SetGroupingParam(
3140         IAudioSessionControl2 *iface, const GUID *group, const GUID *session)
3141 {
3142     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3143
3144     FIXME("(%p)->(%s, %s) - stub\n", This, debugstr_guid(group),
3145             debugstr_guid(session));
3146
3147     return E_NOTIMPL;
3148 }
3149
3150 static HRESULT WINAPI AudioSessionControl_RegisterAudioSessionNotification(
3151         IAudioSessionControl2 *iface, IAudioSessionEvents *events)
3152 {
3153     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3154
3155     FIXME("(%p)->(%p) - stub\n", This, events);
3156
3157     return S_OK;
3158 }
3159
3160 static HRESULT WINAPI AudioSessionControl_UnregisterAudioSessionNotification(
3161         IAudioSessionControl2 *iface, IAudioSessionEvents *events)
3162 {
3163     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3164
3165     FIXME("(%p)->(%p) - stub\n", This, events);
3166
3167     return S_OK;
3168 }
3169
3170 static HRESULT WINAPI AudioSessionControl_GetSessionIdentifier(
3171         IAudioSessionControl2 *iface, WCHAR **id)
3172 {
3173     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3174
3175     FIXME("(%p)->(%p) - stub\n", This, id);
3176
3177     return E_NOTIMPL;
3178 }
3179
3180 static HRESULT WINAPI AudioSessionControl_GetSessionInstanceIdentifier(
3181         IAudioSessionControl2 *iface, WCHAR **id)
3182 {
3183     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3184
3185     FIXME("(%p)->(%p) - stub\n", This, id);
3186
3187     return E_NOTIMPL;
3188 }
3189
3190 static HRESULT WINAPI AudioSessionControl_GetProcessId(
3191         IAudioSessionControl2 *iface, DWORD *pid)
3192 {
3193     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3194
3195     TRACE("(%p)->(%p)\n", This, pid);
3196
3197     if (!pid)
3198         return E_POINTER;
3199
3200     *pid = GetCurrentProcessId();
3201
3202     return S_OK;
3203 }
3204
3205 static HRESULT WINAPI AudioSessionControl_IsSystemSoundsSession(
3206         IAudioSessionControl2 *iface)
3207 {
3208     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3209
3210     TRACE("(%p)\n", This);
3211
3212     return S_FALSE;
3213 }
3214
3215 static HRESULT WINAPI AudioSessionControl_SetDuckingPreference(
3216         IAudioSessionControl2 *iface, BOOL optout)
3217 {
3218     AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3219
3220     TRACE("(%p)->(%d)\n", This, optout);
3221
3222     return S_OK;
3223 }
3224
3225 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl =
3226 {
3227     AudioSessionControl_QueryInterface,
3228     AudioSessionControl_AddRef,
3229     AudioSessionControl_Release,
3230     AudioSessionControl_GetState,
3231     AudioSessionControl_GetDisplayName,
3232     AudioSessionControl_SetDisplayName,
3233     AudioSessionControl_GetIconPath,
3234     AudioSessionControl_SetIconPath,
3235     AudioSessionControl_GetGroupingParam,
3236     AudioSessionControl_SetGroupingParam,
3237     AudioSessionControl_RegisterAudioSessionNotification,
3238     AudioSessionControl_UnregisterAudioSessionNotification,
3239     AudioSessionControl_GetSessionIdentifier,
3240     AudioSessionControl_GetSessionInstanceIdentifier,
3241     AudioSessionControl_GetProcessId,
3242     AudioSessionControl_IsSystemSoundsSession,
3243     AudioSessionControl_SetDuckingPreference
3244 };
3245
3246 typedef struct _SessionMgr {
3247     IAudioSessionManager2 IAudioSessionManager2_iface;
3248
3249     LONG ref;
3250
3251     IMMDevice *device;
3252 } SessionMgr;
3253
3254 static HRESULT WINAPI AudioSessionManager_QueryInterface(IAudioSessionManager2 *iface,
3255         REFIID riid, void **ppv)
3256 {
3257     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
3258
3259     if (!ppv)
3260         return E_POINTER;
3261     *ppv = NULL;
3262
3263     if (IsEqualIID(riid, &IID_IUnknown) ||
3264         IsEqualIID(riid, &IID_IAudioSessionManager) ||
3265         IsEqualIID(riid, &IID_IAudioSessionManager2))
3266         *ppv = iface;
3267     if (*ppv) {
3268         IUnknown_AddRef((IUnknown*)*ppv);
3269         return S_OK;
3270     }
3271
3272     WARN("Unknown interface %s\n", debugstr_guid(riid));
3273     return E_NOINTERFACE;
3274 }
3275
3276 static inline SessionMgr *impl_from_IAudioSessionManager2(IAudioSessionManager2 *iface)
3277 {
3278     return CONTAINING_RECORD(iface, SessionMgr, IAudioSessionManager2_iface);
3279 }
3280
3281 static ULONG WINAPI AudioSessionManager_AddRef(IAudioSessionManager2 *iface)
3282 {
3283     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3284     ULONG ref;
3285     ref = InterlockedIncrement(&This->ref);
3286     TRACE("(%p) Refcount now %u\n", This, ref);
3287     return ref;
3288 }
3289
3290 static ULONG WINAPI AudioSessionManager_Release(IAudioSessionManager2 *iface)
3291 {
3292     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3293     ULONG ref;
3294     ref = InterlockedDecrement(&This->ref);
3295     TRACE("(%p) Refcount now %u\n", This, ref);
3296     if (!ref)
3297         HeapFree(GetProcessHeap(), 0, This);
3298     return ref;
3299 }
3300
3301 static HRESULT WINAPI AudioSessionManager_GetAudioSessionControl(
3302         IAudioSessionManager2 *iface, const GUID *session_guid, DWORD flags,
3303         IAudioSessionControl **out)
3304 {
3305     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3306     AudioSession *session;
3307     AudioSessionWrapper *wrapper;
3308     HRESULT hr;
3309
3310     TRACE("(%p)->(%s, %x, %p)\n", This, debugstr_guid(session_guid),
3311             flags, out);
3312
3313     hr = get_audio_session(session_guid, This->device, 0, &session);
3314     if (FAILED(hr))
3315         return hr;
3316
3317     wrapper = AudioSessionWrapper_Create(NULL);
3318     if (!wrapper)
3319         return E_OUTOFMEMORY;
3320
3321     wrapper->session = session;
3322
3323     *out = (IAudioSessionControl*)&wrapper->IAudioSessionControl2_iface;
3324
3325     return S_OK;
3326 }
3327
3328 static HRESULT WINAPI AudioSessionManager_GetSimpleAudioVolume(
3329         IAudioSessionManager2 *iface, const GUID *session_guid, DWORD flags,
3330         ISimpleAudioVolume **out)
3331 {
3332     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3333     AudioSession *session;
3334     AudioSessionWrapper *wrapper;
3335     HRESULT hr;
3336
3337     TRACE("(%p)->(%s, %x, %p)\n", This, debugstr_guid(session_guid),
3338             flags, out);
3339
3340     hr = get_audio_session(session_guid, This->device, 0, &session);
3341     if (FAILED(hr))
3342         return hr;
3343
3344     wrapper = AudioSessionWrapper_Create(NULL);
3345     if (!wrapper)
3346         return E_OUTOFMEMORY;
3347
3348     wrapper->session = session;
3349
3350     *out = &wrapper->ISimpleAudioVolume_iface;
3351
3352     return S_OK;
3353 }
3354
3355 static HRESULT WINAPI AudioSessionManager_GetSessionEnumerator(
3356         IAudioSessionManager2 *iface, IAudioSessionEnumerator **out)
3357 {
3358     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3359     FIXME("(%p)->(%p) - stub\n", This, out);
3360     return E_NOTIMPL;
3361 }
3362
3363 static HRESULT WINAPI AudioSessionManager_RegisterSessionNotification(
3364         IAudioSessionManager2 *iface, IAudioSessionNotification *notification)
3365 {
3366     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3367     FIXME("(%p)->(%p) - stub\n", This, notification);
3368     return E_NOTIMPL;
3369 }
3370
3371 static HRESULT WINAPI AudioSessionManager_UnregisterSessionNotification(
3372         IAudioSessionManager2 *iface, IAudioSessionNotification *notification)
3373 {
3374     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3375     FIXME("(%p)->(%p) - stub\n", This, notification);
3376     return E_NOTIMPL;
3377 }
3378
3379 static HRESULT WINAPI AudioSessionManager_RegisterDuckNotification(
3380         IAudioSessionManager2 *iface, const WCHAR *session_id,
3381         IAudioVolumeDuckNotification *notification)
3382 {
3383     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3384     FIXME("(%p)->(%p) - stub\n", This, notification);
3385     return E_NOTIMPL;
3386 }
3387
3388 static HRESULT WINAPI AudioSessionManager_UnregisterDuckNotification(
3389         IAudioSessionManager2 *iface,
3390         IAudioVolumeDuckNotification *notification)
3391 {
3392     SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3393     FIXME("(%p)->(%p) - stub\n", This, notification);
3394     return E_NOTIMPL;
3395 }
3396
3397 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl =
3398 {
3399     AudioSessionManager_QueryInterface,
3400     AudioSessionManager_AddRef,
3401     AudioSessionManager_Release,
3402     AudioSessionManager_GetAudioSessionControl,
3403     AudioSessionManager_GetSimpleAudioVolume,
3404     AudioSessionManager_GetSessionEnumerator,
3405     AudioSessionManager_RegisterSessionNotification,
3406     AudioSessionManager_UnregisterSessionNotification,
3407     AudioSessionManager_RegisterDuckNotification,
3408     AudioSessionManager_UnregisterDuckNotification
3409 };
3410
3411 static HRESULT WINAPI SimpleAudioVolume_QueryInterface(
3412         ISimpleAudioVolume *iface, REFIID riid, void **ppv)
3413 {
3414     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
3415
3416     if (!ppv)
3417         return E_POINTER;
3418     *ppv = NULL;
3419
3420     if (IsEqualIID(riid, &IID_IUnknown) ||
3421         IsEqualIID(riid, &IID_ISimpleAudioVolume))
3422         *ppv = iface;
3423     if (*ppv) {
3424         IUnknown_AddRef((IUnknown*)*ppv);
3425         return S_OK;
3426     }
3427
3428     WARN("Unknown interface %s\n", debugstr_guid(riid));
3429     return E_NOINTERFACE;
3430 }
3431
3432 static ULONG WINAPI SimpleAudioVolume_AddRef(ISimpleAudioVolume *iface)
3433 {
3434     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
3435     return AudioSessionControl_AddRef(&This->IAudioSessionControl2_iface);
3436 }
3437
3438 static ULONG WINAPI SimpleAudioVolume_Release(ISimpleAudioVolume *iface)
3439 {
3440     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
3441     return AudioSessionControl_Release(&This->IAudioSessionControl2_iface);
3442 }
3443
3444 static HRESULT WINAPI SimpleAudioVolume_SetMasterVolume(
3445         ISimpleAudioVolume *iface, float level, const GUID *context)
3446 {
3447     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
3448     AudioSession *session = This->session;
3449
3450     TRACE("(%p)->(%f, %s)\n", session, level, wine_dbgstr_guid(context));
3451
3452     if (level < 0.f || level > 1.f)
3453         return E_INVALIDARG;
3454
3455     if (context)
3456         FIXME("Notifications not supported yet\n");
3457
3458     TRACE("PulseAudio does not support session volume control\n");
3459
3460     pthread_mutex_lock(&pulse_lock);
3461     session->master_vol = level;
3462     pthread_mutex_unlock(&pulse_lock);
3463
3464     return S_OK;
3465 }
3466
3467 static HRESULT WINAPI SimpleAudioVolume_GetMasterVolume(
3468         ISimpleAudioVolume *iface, float *level)
3469 {
3470     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
3471     AudioSession *session = This->session;
3472
3473     TRACE("(%p)->(%p)\n", session, level);
3474
3475     if (!level)
3476         return NULL_PTR_ERR;
3477
3478     *level = session->master_vol;
3479
3480     return S_OK;
3481 }
3482
3483 static HRESULT WINAPI SimpleAudioVolume_SetMute(ISimpleAudioVolume *iface,
3484         BOOL mute, const GUID *context)
3485 {
3486     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
3487     AudioSession *session = This->session;
3488
3489     TRACE("(%p)->(%u, %s)\n", session, mute, debugstr_guid(context));
3490
3491     if (context)
3492         FIXME("Notifications not supported yet\n");
3493
3494     session->mute = mute;
3495
3496     return S_OK;
3497 }
3498
3499 static HRESULT WINAPI SimpleAudioVolume_GetMute(ISimpleAudioVolume *iface,
3500         BOOL *mute)
3501 {
3502     AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
3503     AudioSession *session = This->session;
3504
3505     TRACE("(%p)->(%p)\n", session, mute);
3506
3507     if (!mute)
3508         return NULL_PTR_ERR;
3509
3510     *mute = session->mute;
3511
3512     return S_OK;
3513 }
3514
3515 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl  =
3516 {
3517     SimpleAudioVolume_QueryInterface,
3518     SimpleAudioVolume_AddRef,
3519     SimpleAudioVolume_Release,
3520     SimpleAudioVolume_SetMasterVolume,
3521     SimpleAudioVolume_GetMasterVolume,
3522     SimpleAudioVolume_SetMute,
3523     SimpleAudioVolume_GetMute
3524 };
3525
3526 static HRESULT WINAPI ChannelAudioVolume_QueryInterface(
3527         IChannelAudioVolume *iface, REFIID riid, void **ppv)
3528 {
3529     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
3530
3531     if (!ppv)
3532         return E_POINTER;
3533     *ppv = NULL;
3534
3535     if (IsEqualIID(riid, &IID_IUnknown) ||
3536         IsEqualIID(riid, &IID_IChannelAudioVolume))
3537         *ppv = iface;
3538     if (*ppv) {
3539         IUnknown_AddRef((IUnknown*)*ppv);
3540         return S_OK;
3541     }
3542
3543     WARN("Unknown interface %s\n", debugstr_guid(riid));
3544     return E_NOINTERFACE;
3545 }
3546
3547 static ULONG WINAPI ChannelAudioVolume_AddRef(IChannelAudioVolume *iface)
3548 {
3549     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3550     return AudioSessionControl_AddRef(&This->IAudioSessionControl2_iface);
3551 }
3552
3553 static ULONG WINAPI ChannelAudioVolume_Release(IChannelAudioVolume *iface)
3554 {
3555     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3556     return AudioSessionControl_Release(&This->IAudioSessionControl2_iface);
3557 }
3558
3559 static HRESULT WINAPI ChannelAudioVolume_GetChannelCount(
3560         IChannelAudioVolume *iface, UINT32 *out)
3561 {
3562     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3563     AudioSession *session = This->session;
3564
3565     TRACE("(%p)->(%p)\n", session, out);
3566
3567     if (!out)
3568         return NULL_PTR_ERR;
3569
3570     *out = session->channel_count;
3571
3572     return S_OK;
3573 }
3574
3575 static HRESULT WINAPI ChannelAudioVolume_SetChannelVolume(
3576         IChannelAudioVolume *iface, UINT32 index, float level,
3577         const GUID *context)
3578 {
3579     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3580     AudioSession *session = This->session;
3581
3582     TRACE("(%p)->(%d, %f, %s)\n", session, index, level,
3583             wine_dbgstr_guid(context));
3584
3585     if (level < 0.f || level > 1.f)
3586         return E_INVALIDARG;
3587
3588     if (index >= session->channel_count)
3589         return E_INVALIDARG;
3590
3591     if (context)
3592         FIXME("Notifications not supported yet\n");
3593
3594     TRACE("PulseAudio does not support session volume control\n");
3595
3596     pthread_mutex_lock(&pulse_lock);
3597     session->channel_vols[index] = level;
3598     pthread_mutex_unlock(&pulse_lock);
3599
3600     return S_OK;
3601 }
3602
3603 static HRESULT WINAPI ChannelAudioVolume_GetChannelVolume(
3604         IChannelAudioVolume *iface, UINT32 index, float *level)
3605 {
3606     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3607     AudioSession *session = This->session;
3608
3609     TRACE("(%p)->(%d, %p)\n", session, index, level);
3610
3611     if (!level)
3612         return NULL_PTR_ERR;
3613
3614     if (index >= session->channel_count)
3615         return E_INVALIDARG;
3616
3617     *level = session->channel_vols[index];
3618
3619     return S_OK;
3620 }
3621
3622 static HRESULT WINAPI ChannelAudioVolume_SetAllVolumes(
3623         IChannelAudioVolume *iface, UINT32 count, const float *levels,
3624         const GUID *context)
3625 {
3626     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3627     AudioSession *session = This->session;
3628     int i;
3629
3630     TRACE("(%p)->(%d, %p, %s)\n", session, count, levels,
3631             wine_dbgstr_guid(context));
3632
3633     if (!levels)
3634         return NULL_PTR_ERR;
3635
3636     if (count != session->channel_count)
3637         return E_INVALIDARG;
3638
3639     if (context)
3640         FIXME("Notifications not supported yet\n");
3641
3642     TRACE("PulseAudio does not support session volume control\n");
3643
3644     pthread_mutex_lock(&pulse_lock);
3645     for(i = 0; i < count; ++i)
3646         session->channel_vols[i] = levels[i];
3647     pthread_mutex_unlock(&pulse_lock);
3648     return S_OK;
3649 }
3650
3651 static HRESULT WINAPI ChannelAudioVolume_GetAllVolumes(
3652         IChannelAudioVolume *iface, UINT32 count, float *levels)
3653 {
3654     AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3655     AudioSession *session = This->session;
3656     int i;
3657
3658     TRACE("(%p)->(%d, %p)\n", session, count, levels);
3659
3660     if (!levels)
3661         return NULL_PTR_ERR;
3662
3663     if (count != session->channel_count)
3664         return E_INVALIDARG;
3665
3666     for(i = 0; i < count; ++i)
3667         levels[i] = session->channel_vols[i];
3668
3669     return S_OK;
3670 }
3671
3672 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl =
3673 {
3674     ChannelAudioVolume_QueryInterface,
3675     ChannelAudioVolume_AddRef,
3676     ChannelAudioVolume_Release,
3677     ChannelAudioVolume_GetChannelCount,
3678     ChannelAudioVolume_SetChannelVolume,
3679     ChannelAudioVolume_GetChannelVolume,
3680     ChannelAudioVolume_SetAllVolumes,
3681     ChannelAudioVolume_GetAllVolumes
3682 };
3683
3684 HRESULT WINAPI AUDDRV_GetAudioSessionManager(IMMDevice *device,
3685         IAudioSessionManager2 **out)
3686 {
3687     SessionMgr *This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SessionMgr));
3688     *out = NULL;
3689     if (!This)
3690         return E_OUTOFMEMORY;
3691     This->IAudioSessionManager2_iface.lpVtbl = &AudioSessionManager2_Vtbl;
3692     This->device = device;
3693     This->ref = 1;
3694     *out = &This->IAudioSessionManager2_iface;
3695     return S_OK;
3696 }
3697
3698 HRESULT WINAPI AUDDRV_GetPropValue(GUID *guid, const PROPERTYKEY *prop, PROPVARIANT *out)
3699 {
3700     TRACE("%s, (%s,%u), %p\n", wine_dbgstr_guid(guid), wine_dbgstr_guid(&prop->fmtid), prop->pid, out);
3701
3702     if (IsEqualGUID(guid, &pulse_render_guid) && IsEqualPropertyKey(*prop, PKEY_AudioEndpoint_PhysicalSpeakers)) {
3703         out->vt = VT_UI4;
3704         out->u.ulVal = g_phys_speakers_mask;
3705
3706         return out->u.ulVal ? S_OK : E_FAIL;
3707     }
3708
3709     return E_NOTIMPL;
3710 }
3711
3712
3713
3714 /**********************************************************************
3715  * A-law and u-law sample manipulation functions
3716  * Multiply with the given volume (vol must be between 0...1 inclusive)
3717  *
3718  * These were taken from PulseAudio's sources but adjusted to directly
3719  * fit our usage (since we use floats directly) so they should be exact.
3720  */
3721 static UINT8 mult_alaw_sample(UINT8 sample, float vol)
3722 {
3723     static const float decode_to_13bits_float[1 << 8] =
3724     {
3725          -688.0f,  -656.0f,  -752.0f,  -720.0f,  -560.0f,  -528.0f,  -624.0f,  -592.0f,
3726          -944.0f,  -912.0f, -1008.0f,  -976.0f,  -816.0f,  -784.0f,  -880.0f,  -848.0f,
3727          -344.0f,  -328.0f,  -376.0f,  -360.0f,  -280.0f,  -264.0f,  -312.0f,  -296.0f,
3728          -472.0f,  -456.0f,  -504.0f,  -488.0f,  -408.0f,  -392.0f,  -440.0f,  -424.0f,
3729         -2752.0f, -2624.0f, -3008.0f, -2880.0f, -2240.0f, -2112.0f, -2496.0f, -2368.0f,
3730         -3776.0f, -3648.0f, -4032.0f, -3904.0f, -3264.0f, -3136.0f, -3520.0f, -3392.0f,
3731         -1376.0f, -1312.0f, -1504.0f, -1440.0f, -1120.0f, -1056.0f, -1248.0f, -1184.0f,
3732         -1888.0f, -1824.0f, -2016.0f, -1952.0f, -1632.0f, -1568.0f, -1760.0f, -1696.0f,
3733           -43.0f,   -41.0f,   -47.0f,   -45.0f,   -35.0f,   -33.0f,   -39.0f,   -37.0f,
3734           -59.0f,   -57.0f,   -63.0f,   -61.0f,   -51.0f,   -49.0f,   -55.0f,   -53.0f,
3735           -11.0f,    -9.0f,   -15.0f,   -13.0f,    -3.0f,    -1.0f,    -7.0f,    -5.0f,
3736           -27.0f,   -25.0f,   -31.0f,   -29.0f,   -19.0f,   -17.0f,   -23.0f,   -21.0f,
3737          -172.0f,  -164.0f,  -188.0f,  -180.0f,  -140.0f,  -132.0f,  -156.0f,  -148.0f,
3738          -236.0f,  -228.0f,  -252.0f,  -244.0f,  -204.0f,  -196.0f,  -220.0f,  -212.0f,
3739           -86.0f,   -82.0f,   -94.0f,   -90.0f,   -70.0f,   -66.0f,   -78.0f,   -74.0f,
3740          -118.0f,  -114.0f,  -126.0f,  -122.0f,  -102.0f,   -98.0f,  -110.0f,  -106.0f,
3741           688.0f,   656.0f,   752.0f,   720.0f,   560.0f,   528.0f,   624.0f,   592.0f,
3742           944.0f,   912.0f,  1008.0f,   976.0f,   816.0f,   784.0f,   880.0f,   848.0f,
3743           344.0f,   328.0f,   376.0f,   360.0f,   280.0f,   264.0f,   312.0f,   296.0f,
3744           472.0f,   456.0f,   504.0f,   488.0f,   408.0f,   392.0f,   440.0f,   424.0f,
3745          2752.0f,  2624.0f,  3008.0f,  2880.0f,  2240.0f,  2112.0f,  2496.0f,  2368.0f,
3746          3776.0f,  3648.0f,  4032.0f,  3904.0f,  3264.0f,  3136.0f,  3520.0f,  3392.0f,
3747          1376.0f,  1312.0f,  1504.0f,  1440.0f,  1120.0f,  1056.0f,  1248.0f,  1184.0f,
3748          1888.0f,  1824.0f,  2016.0f,  1952.0f,  1632.0f,  1568.0f,  1760.0f,  1696.0f,
3749            43.0f,    41.0f,    47.0f,    45.0f,    35.0f,    33.0f,    39.0f,    37.0f,
3750            59.0f,    57.0f,    63.0f,    61.0f,    51.0f,    49.0f,    55.0f,    53.0f,
3751            11.0f,     9.0f,    15.0f,    13.0f,     3.0f,     1.0f,     7.0f,     5.0f,
3752            27.0f,    25.0f,    31.0f,    29.0f,    19.0f,    17.0f,    23.0f,    21.0f,
3753           172.0f,   164.0f,   188.0f,   180.0f,   140.0f,   132.0f,   156.0f,   148.0f,
3754           236.0f,   228.0f,   252.0f,   244.0f,   204.0f,   196.0f,   220.0f,   212.0f,
3755            86.0f,    82.0f,    94.0f,    90.0f,    70.0f,    66.0f,    78.0f,    74.0f,
3756           118.0f,   114.0f,   126.0f,   122.0f,   102.0f,    98.0f,   110.0f,   106.0f
3757     };
3758
3759     static const UINT8 encode[1 << 13] =
3760     {
3761         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
3762         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
3763         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
3764         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
3765         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
3766         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
3767         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
3768         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
3769         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
3770         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2b, 0x2b,
3771         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
3772         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
3773         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
3774         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
3775         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
3776         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
3777         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
3778         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
3779         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
3780         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x28, 0x28, 0x28, 0x28,
3781         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
3782         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
3783         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
3784         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
3785         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
3786         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
3787         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
3788         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
3789         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
3790         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
3791         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
3792         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
3793         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
3794         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
3795         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
3796         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
3797         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
3798         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
3799         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
3800         0x29, 0x29, 0x29, 0x29, 0x29, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
3801         0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
3802         0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
3803         0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
3804         0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
3805         0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
3806         0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
3807         0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
3808         0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
3809         0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
3810         0x2e, 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
3811         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
3812         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
3813         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
3814         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
3815         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
3816         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
3817         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
3818         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
3819         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
3820         0x2f, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
3821         0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
3822         0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
3823         0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
3824         0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
3825         0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
3826         0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
3827         0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
3828         0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
3829         0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2d,
3830         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
3831         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
3832         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
3833         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
3834         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
3835         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
3836         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
3837         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
3838         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
3839         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x22, 0x22, 0x22,
3840         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
3841         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
3842         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
3843         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
3844         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
3845         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
3846         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
3847         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
3848         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
3849         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x23, 0x23, 0x23, 0x23, 0x23,
3850         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
3851         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
3852         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
3853         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
3854         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
3855         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
3856         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
3857         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
3858         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
3859         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
3860         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
3861         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
3862         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
3863         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
3864         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
3865         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
3866         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
3867         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
3868         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
3869         0x20, 0x20, 0x20, 0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
3870         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
3871         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
3872         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
3873         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
3874         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
3875         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
3876         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
3877         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
3878         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
3879         0x21, 0x21, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
3880         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
3881         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
3882         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
3883         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
3884         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
3885         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
3886         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
3887         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
3888         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
3889         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
3890         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
3891         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
3892         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
3893         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
3894         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
3895         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
3896         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
3897         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
3898         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x24, 0x24,
3899         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
3900         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
3901         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
3902         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
3903         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
3904         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
3905         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
3906         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
3907         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
3908         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x25, 0x25, 0x25, 0x25,
3909         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
3910         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
3911         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
3912         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
3913         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
3914         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
3915         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
3916         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
3917         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
3918         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
3919         0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
3920         0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
3921         0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
3922         0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
3923         0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
3924         0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
3925         0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
3926         0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
3927         0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
3928         0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
3929         0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
3930         0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
3931         0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
3932         0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
3933         0x38, 0x38, 0x38, 0x38, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
3934         0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
3935         0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
3936         0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
3937         0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
3938         0x39, 0x39, 0x39, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
3939         0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
3940         0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
3941         0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
3942         0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
3943         0x3e, 0x3e, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
3944         0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
3945         0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
3946         0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
3947         0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
3948         0x3f, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
3949         0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
3950         0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
3951         0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
3952         0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
3953         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
3954         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
3955         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
3956         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
3957         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x32,
3958         0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
3959         0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
3960         0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
3961         0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
3962         0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x33, 0x33,
3963         0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
3964         0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
3965         0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
3966         0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
3967         0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x30, 0x30, 0x30,
3968         0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
3969         0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
3970         0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
3971         0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
3972         0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, 0x31,
3973         0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
3974         0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
3975         0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
3976         0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
3977         0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x36, 0x36, 0x36, 0x36, 0x36,
3978         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
3979         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
3980         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
3981         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
3982         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
3983         0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
3984         0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
3985         0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
3986         0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
3987         0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
3988         0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
3989         0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
3990         0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
3991         0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
3992         0x34, 0x34, 0x34, 0x34, 0x34, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
3993         0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
3994         0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
3995         0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
3996         0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
3997         0x35, 0x35, 0x35, 0x35, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
3998         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
3999         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b,
4000         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4001         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4002         0x0b, 0x0b, 0x0b, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4003         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4004         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09, 0x09, 0x09,
4005         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4006         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4007         0x09, 0x09, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4008         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4009         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4010         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4011         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4012         0x0f, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4013         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4014         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4015         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4016         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4017         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4018         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4019         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4020         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4021         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00,
4022         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4023         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4024         0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4025         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4026         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x06, 0x06,
4027         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4028         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4029         0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4030         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4031         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x04, 0x04, 0x04,
4032         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4033         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4034         0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4035         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4036         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x1a, 0x1a, 0x1a, 0x1a,
4037         0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1b,
4038         0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
4039         0x1b, 0x1b, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
4040         0x18, 0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
4041         0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
4042         0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1f, 0x1f,
4043         0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
4044         0x1f, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
4045         0x1c, 0x1c, 0x1c, 0x1c, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
4046         0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
4047         0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x13, 0x13, 0x13,
4048         0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
4049         0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
4050         0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
4051         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
4052         0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17,
4053         0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x14,
4054         0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
4055         0x14, 0x14, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
4056         0x15, 0x15, 0x15, 0x15, 0x15, 0x6a, 0x6a, 0x6a, 0x6a, 0x6a, 0x6a, 0x6a, 0x6a,
4057         0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x6b, 0x68, 0x68, 0x68, 0x68, 0x68,
4058         0x68, 0x68, 0x68, 0x69, 0x69, 0x69, 0x69, 0x69, 0x69, 0x69, 0x69, 0x6e, 0x6e,
4059         0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6e, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
4060         0x6f, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6d, 0x6d, 0x6d, 0x6d,
4061         0x6d, 0x6d, 0x6d, 0x6d, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x62, 0x63,
4062         0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60,
4063         0x60, 0x60, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x66, 0x66, 0x66,
4064         0x66, 0x66, 0x66, 0x66, 0x66, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67, 0x67,
4065         0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x64, 0x65, 0x65, 0x65, 0x65, 0x65,
4066         0x65, 0x65, 0x65, 0x7a, 0x7a, 0x7a, 0x7a, 0x7b, 0x7b, 0x7b, 0x7b, 0x78, 0x78,
4067         0x78, 0x78, 0x79, 0x79, 0x79, 0x79, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f,
4068         0x7f, 0x7c, 0x7c, 0x7c, 0x7c, 0x7d, 0x7d, 0x7d, 0x7d, 0x72, 0x72, 0x72, 0x72,
4069         0x73, 0x73, 0x73, 0x73, 0x70, 0x70, 0x70, 0x70, 0x71, 0x71, 0x71, 0x71, 0x76,
4070         0x76, 0x76, 0x76, 0x77, 0x77, 0x77, 0x77, 0x74, 0x74, 0x74, 0x74, 0x75, 0x75,
4071         0x75, 0x75, 0x4a, 0x4a, 0x4b, 0x4b, 0x48, 0x48, 0x49, 0x49, 0x4e, 0x4e, 0x4f,
4072         0x4f, 0x4c, 0x4c, 0x4d, 0x4d, 0x42, 0x42, 0x43, 0x43, 0x40, 0x40, 0x41, 0x41,
4073         0x46, 0x46, 0x47, 0x47, 0x44, 0x44, 0x45, 0x45, 0x5a, 0x5a, 0x5b, 0x5b, 0x58,
4074         0x58, 0x59, 0x59, 0x5e, 0x5e, 0x5f, 0x5f, 0x5c, 0x5c, 0x5d, 0x5d, 0x52, 0x52,
4075         0x53, 0x53, 0x50, 0x50, 0x51, 0x51, 0x56, 0x56, 0x57, 0x57, 0x54, 0x54, 0x55,
4076         0x55, 0xd5, 0xd5, 0xd4, 0xd4, 0xd7, 0xd7, 0xd6, 0xd6, 0xd1, 0xd1, 0xd0, 0xd0,
4077         0xd3, 0xd3, 0xd2, 0xd2, 0xdd, 0xdd, 0xdc, 0xdc, 0xdf, 0xdf, 0xde, 0xde, 0xd9,
4078         0xd9, 0xd8, 0xd8, 0xdb, 0xdb, 0xda, 0xda, 0xc5, 0xc5, 0xc4, 0xc4, 0xc7, 0xc7,
4079         0xc6, 0xc6, 0xc1, 0xc1, 0xc0, 0xc0, 0xc3, 0xc3, 0xc2, 0xc2, 0xcd, 0xcd, 0xcc,
4080         0xcc, 0xcf, 0xcf, 0xce, 0xce, 0xc9, 0xc9, 0xc8, 0xc8, 0xcb, 0xcb, 0xca, 0xca,
4081         0xf5, 0xf5, 0xf5, 0xf5, 0xf4, 0xf4, 0xf4, 0xf4, 0xf7, 0xf7, 0xf7, 0xf7, 0xf6,
4082         0xf6, 0xf6, 0xf6, 0xf1, 0xf1, 0xf1, 0xf1, 0xf0, 0xf0, 0xf0, 0xf0, 0xf3, 0xf3,
4083         0xf3, 0xf3, 0xf2, 0xf2, 0xf2, 0xf2, 0xfd, 0xfd, 0xfd, 0xfd, 0xfc, 0xfc, 0xfc,
4084         0xfc, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfe, 0xf9, 0xf9, 0xf9, 0xf9,
4085         0xf8, 0xf8, 0xf8, 0xf8, 0xfb, 0xfb, 0xfb, 0xfb, 0xfa, 0xfa, 0xfa, 0xfa, 0xe5,
4086         0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4, 0xe4,
4087         0xe4, 0xe4, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xe6, 0xe6, 0xe6,
4088         0xe6, 0xe6, 0xe6, 0xe6, 0xe6, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1, 0xe1,
4089         0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe3, 0xe3, 0xe3, 0xe3, 0xe3,
4090         0xe3, 0xe3, 0xe3, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xe2, 0xed, 0xed,
4091         0xed, 0xed, 0xed, 0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec, 0xec,
4092         0xec, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xee, 0xee, 0xee, 0xee,
4093         0xee, 0xee, 0xee, 0xee, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe9, 0xe8,
4094         0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xe8, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb, 0xeb,
4095         0xeb, 0xeb, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0xea, 0x95, 0x95, 0x95,
4096         0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
4097         0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
4098         0x94, 0x94, 0x94, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
4099         0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
4100         0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x91, 0x91, 0x91, 0x91,
4101         0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x90,
4102         0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
4103         0x90, 0x90, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
4104         0x93, 0x93, 0x93, 0x93, 0x93, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
4105         0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
4106         0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9c, 0x9c,
4107         0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
4108         0x9c, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
4109         0x9f, 0x9f, 0x9f, 0x9f, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
4110         0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
4111         0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x98, 0x98, 0x98,
4112         0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
4113         0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
4114         0x9b, 0x9b, 0x9b, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
4115         0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
4116         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
4117         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x84,
4118         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
4119         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
4120         0x84, 0x84, 0x84, 0x84, 0x84, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
4121         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
4122         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x86, 0x86,
4123         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
4124         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
4125         0x86, 0x86, 0x86, 0x86, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
4126         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
4127         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x80, 0x80, 0x80,
4128         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
4129         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
4130         0x80, 0x80, 0x80, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
4131         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
4132         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82,
4133         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
4134         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
4135         0x82, 0x82, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
4136         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
4137         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
4138         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
4139         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
4140         0x8c, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
4141         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
4142         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
4143         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
4144         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
4145         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
4146         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
4147         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
4148         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
4149         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x8b,
4150         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
4151         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
4152         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
4153         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
4154         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0xb5, 0xb5,
4155         0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
4156         0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
4157         0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
4158         0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
4159         0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb4, 0xb4, 0xb4,
4160         0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
4161         0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
4162         0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
4163         0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
4164         0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb7, 0xb7, 0xb7, 0xb7,
4165         0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
4166         0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
4167         0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
4168         0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
4169         0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
4170         0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
4171         0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
4172         0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
4173         0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
4174         0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
4175         0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
4176         0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
4177         0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
4178         0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
4179         0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
4180         0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
4181         0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
4182         0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
4183         0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
4184         0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
4185         0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
4186         0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
4187         0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
4188         0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
4189         0xb3, 0xb3, 0xb3, 0xb3, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
4190         0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
4191         0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
4192         0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
4193         0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
4194         0xb2, 0xb2, 0xb2, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
4195         0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
4196         0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
4197         0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
4198         0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
4199         0xbd, 0xbd, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
4200         0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
4201         0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
4202         0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
4203         0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
4204         0xbc, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
4205         0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
4206         0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
4207         0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
4208         0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
4209         0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
4210         0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
4211         0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
4212         0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
4213         0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xb9,
4214         0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
4215         0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
4216         0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
4217         0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
4218         0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb8, 0xb8,
4219         0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
4220         0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
4221         0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
4222         0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
4223         0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xbb, 0xbb, 0xbb,
4224         0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
4225         0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
4226         0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
4227         0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
4228         0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xba, 0xba, 0xba, 0xba,
4229         0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
4230         0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
4231         0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
4232         0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
4233         0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
4234         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
4235         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
4236         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
4237         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
4238         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
4239         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
4240         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
4241         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
4242         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
4243         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
4244         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
4245         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
4246         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
4247         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
4248         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
4249         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
4250         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
4251         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
4252         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
4253         0xa4, 0xa4, 0xa4, 0xa4, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
4254         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
4255         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
4256         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
4257         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
4258         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
4259         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
4260         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
4261         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
4262         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
4263         0xa7, 0xa7, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
4264         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
4265         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
4266         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
4267         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
4268         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
4269         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
4270         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
4271         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
4272         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
4273         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
4274         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
4275         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
4276         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
4277         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
4278         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
4279         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
4280         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
4281         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
4282         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa0, 0xa0,
4283         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
4284         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
4285         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
4286         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
4287         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
4288         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
4289         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
4290         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
4291         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
4292         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa3, 0xa3, 0xa3, 0xa3,
4293         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
4294         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
4295         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
4296         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
4297         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
4298         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
4299         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
4300         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
4301         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
4302         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
4303         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
4304         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
4305         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
4306         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
4307         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
4308         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
4309         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
4310         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
4311         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
4312         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
4313         0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
4314         0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
4315         0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
4316         0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
4317         0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
4318         0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
4319         0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
4320         0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
4321         0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
4322         0xad, 0xad, 0xad, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
4323         0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
4324         0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
4325         0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
4326         0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
4327         0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
4328         0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
4329         0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
4330         0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
4331         0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
4332         0xac, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
4333         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
4334         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
4335         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
4336         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
4337         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
4338         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
4339         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
4340         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
4341         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xae,
4342         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
4343         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
4344         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
4345         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
4346         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
4347         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
4348         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
4349         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
4350         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
4351         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xa9, 0xa9, 0xa9,
4352         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
4353         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
4354         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
4355         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
4356         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
4357         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
4358         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
4359         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
4360         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
4361         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
4362         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
4363         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
4364         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
4365         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
4366         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
4367         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
4368         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
4369         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
4370         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
4371         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
4372         0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
4373         0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
4374         0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
4375         0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
4376         0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
4377         0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
4378         0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
4379         0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
4380         0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
4381         0xab, 0xab, 0xab, 0xab, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
4382         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
4383         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
4384         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
4385         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
4386         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
4387         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
4388         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
4389         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
4390         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
4391         0xaa, 0xaa
4392     };
4393
4394     return encode[(int)(vol * decode_to_13bits_float[sample]) + ARRAY_SIZE(encode) / 2];
4395 }
4396
4397 static UINT8 mult_ulaw_sample(UINT8 sample, float vol)
4398 {
4399     static const float decode_to_14bits_float[1 << 8] =
4400     {
4401         -8031.0f, -7775.0f, -7519.0f, -7263.0f, -7007.0f, -6751.0f, -6495.0f, -6239.0f,
4402         -5983.0f, -5727.0f, -5471.0f, -5215.0f, -4959.0f, -4703.0f, -4447.0f, -4191.0f,
4403         -3999.0f, -3871.0f, -3743.0f, -3615.0f, -3487.0f, -3359.0f, -3231.0f, -3103.0f,
4404         -2975.0f, -2847.0f, -2719.0f, -2591.0f, -2463.0f, -2335.0f, -2207.0f, -2079.0f,
4405         -1983.0f, -1919.0f, -1855.0f, -1791.0f, -1727.0f, -1663.0f, -1599.0f, -1535.0f,
4406         -1471.0f, -1407.0f, -1343.0f, -1279.0f, -1215.0f, -1151.0f, -1087.0f, -1023.0f,
4407          -975.0f,  -943.0f,  -911.0f,  -879.0f,  -847.0f,  -815.0f,  -783.0f,  -751.0f,
4408          -719.0f,  -687.0f,  -655.0f,  -623.0f,  -591.0f,  -559.0f,  -527.0f,  -495.0f,
4409          -471.0f,  -455.0f,  -439.0f,  -423.0f,  -407.0f,  -391.0f,  -375.0f,  -359.0f,
4410          -343.0f,  -327.0f,  -311.0f,  -295.0f,  -279.0f,  -263.0f,  -247.0f,  -231.0f,
4411          -219.0f,  -211.0f,  -203.0f,  -195.0f,  -187.0f,  -179.0f,  -171.0f,  -163.0f,
4412          -155.0f,  -147.0f,  -139.0f,  -131.0f,  -123.0f,  -115.0f,  -107.0f,   -99.0f,
4413           -93.0f,   -89.0f,   -85.0f,   -81.0f,   -77.0f,   -73.0f,   -69.0f,   -65.0f,
4414           -61.0f,   -57.0f,   -53.0f,   -49.0f,   -45.0f,   -41.0f,   -37.0f,   -33.0f,
4415           -30.0f,   -28.0f,   -26.0f,   -24.0f,   -22.0f,   -20.0f,   -18.0f,   -16.0f,
4416           -14.0f,   -12.0f,   -10.0f,    -8.0f,    -6.0f,    -4.0f,    -2.0f,     0.0f,
4417          8031.0f,  7775.0f,  7519.0f,  7263.0f,  7007.0f,  6751.0f,  6495.0f,  6239.0f,
4418          5983.0f,  5727.0f,  5471.0f,  5215.0f,  4959.0f,  4703.0f,  4447.0f,  4191.0f,
4419          3999.0f,  3871.0f,  3743.0f,  3615.0f,  3487.0f,  3359.0f,  3231.0f,  3103.0f,
4420          2975.0f,  2847.0f,  2719.0f,  2591.0f,  2463.0f,  2335.0f,  2207.0f,  2079.0f,
4421          1983.0f,  1919.0f,  1855.0f,  1791.0f,  1727.0f,  1663.0f,  1599.0f,  1535.0f,
4422          1471.0f,  1407.0f,  1343.0f,  1279.0f,  1215.0f,  1151.0f,  1087.0f,  1023.0f,
4423           975.0f,   943.0f,   911.0f,   879.0f,   847.0f,   815.0f,   783.0f,   751.0f,
4424           719.0f,   687.0f,   655.0f,   623.0f,   591.0f,   559.0f,   527.0f,   495.0f,
4425           471.0f,   455.0f,   439.0f,   423.0f,   407.0f,   391.0f,   375.0f,   359.0f,
4426           343.0f,   327.0f,   311.0f,   295.0f,   279.0f,   263.0f,   247.0f,   231.0f,
4427           219.0f,   211.0f,   203.0f,   195.0f,   187.0f,   179.0f,   171.0f,   163.0f,
4428           155.0f,   147.0f,   139.0f,   131.0f,   123.0f,   115.0f,   107.0f,    99.0f,
4429            93.0f,    89.0f,    85.0f,    81.0f,    77.0f,    73.0f,    69.0f,    65.0f,
4430            61.0f,    57.0f,    53.0f,    49.0f,    45.0f,    41.0f,    37.0f,    33.0f,
4431            30.0f,    28.0f,    26.0f,    24.0f,    22.0f,    20.0f,    18.0f,    16.0f,
4432            14.0f,    12.0f,    10.0f,     8.0f,     6.0f,     4.0f,     2.0f,     0.0f
4433     };
4434
4435     static const UINT8 encode[1 << 14] =
4436     {
4437         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4438         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4439         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4440         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4441         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4442         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4443         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4444         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4445         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4446         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4447         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4448         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4449         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4450         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4451         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4452         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4453         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4454         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4455         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4456         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4457         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4458         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4459         0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4460         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4461         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4462         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4463         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4464         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4465         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4466         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4467         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4468         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4469         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4470         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4471         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4472         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4473         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4474         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4475         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4476         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4477         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4478         0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
4479         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4480         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4481         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4482         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4483         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4484         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4485         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4486         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4487         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4488         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4489         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4490         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4491         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4492         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4493         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4494         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4495         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4496         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4497         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
4498         0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x03,
4499         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4500         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4501         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4502         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4503         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4504         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4505         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4506         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4507         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4508         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4509         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4510         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4511         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4512         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4513         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4514         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4515         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4516         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4517         0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
4518         0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4519         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4520         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4521         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4522         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4523         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4524         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4525         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4526         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4527         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4528         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4529         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4530         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4531         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4532         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4533         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4534         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4535         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4536         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4537         0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
4538         0x04, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4539         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4540         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4541         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4542         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4543         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4544         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4545         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4546         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4547         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4548         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4549         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4550         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4551         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4552         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4553         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4554         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4555         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4556         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
4557         0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06,
4558         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4559         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4560         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4561         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4562         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4563         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4564         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4565         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4566         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4567         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4568         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4569         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4570         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4571         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4572         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4573         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4574         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4575         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4576         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
4577         0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4578         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4579         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4580         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4581         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4582         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4583         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4584         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4585         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4586         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4587         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4588         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4589         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4590         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4591         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4592         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4593         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4594         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4595         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4596         0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
4597         0x07, 0x07, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4598         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4599         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4600         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4601         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4602         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4603         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4604         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4605         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4606         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4607         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4608         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4609         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4610         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4611         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4612         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4613         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4614         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4615         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
4616         0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x09, 0x09,
4617         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4618         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4619         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4620         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4621         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4622         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4623         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4624         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4625         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4626         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4627         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4628         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4629         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4630         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4631         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4632         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4633         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4634         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4635         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
4636         0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4637         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4638         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4639         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4640         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4641         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4642         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4643         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4644         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4645         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4646         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4647         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4648         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4649         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4650         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4651         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4652         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4653         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4654         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4655         0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
4656         0x0a, 0x0a, 0x0a, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4657         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4658         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4659         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4660         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4661         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4662         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4663         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4664         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4665         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4666         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4667         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4668         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4669         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4670         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4671         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4672         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4673         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4674         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
4675         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0c,
4676         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4677         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4678         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4679         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4680         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4681         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4682         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4683         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4684         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4685         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4686         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4687         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4688         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4689         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4690         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4691         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4692         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4693         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4694         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
4695         0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4696         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4697         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4698         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4699         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4700         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4701         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4702         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4703         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4704         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4705         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4706         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4707         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4708         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4709         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4710         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4711         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4712         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4713         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4714         0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
4715         0x0d, 0x0d, 0x0d, 0x0d, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4716         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4717         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4718         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4719         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4720         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4721         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4722         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4723         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4724         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4725         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4726         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4727         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4728         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4729         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4730         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4731         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4732         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4733         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4734         0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
4735         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4736         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4737         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4738         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4739         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4740         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4741         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4742         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4743         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4744         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4745         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4746         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4747         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4748         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4749         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4750         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4751         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4752         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4753         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
4754         0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x10, 0x10, 0x10, 0x10,
4755         0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
4756         0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
4757         0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
4758         0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
4759         0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
4760         0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
4761         0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
4762         0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
4763         0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
4764         0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
4765         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
4766         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
4767         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
4768         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
4769         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
4770         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
4771         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
4772         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
4773         0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
4774         0x11, 0x11, 0x11, 0x11, 0x11, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
4775         0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
4776         0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
4777         0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
4778         0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
4779         0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
4780         0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
4781         0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
4782         0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
4783         0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12, 0x12,
4784         0x12, 0x12, 0x12, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
4785         0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
4786         0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
4787         0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
4788         0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
4789         0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
4790         0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
4791         0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
4792         0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
4793         0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13, 0x13,
4794         0x13, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
4795         0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
4796         0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
4797         0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
4798         0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
4799         0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
4800         0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
4801         0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
4802         0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14,
4803         0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x14, 0x15,
4804         0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
4805         0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
4806         0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
4807         0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
4808         0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
4809         0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
4810         0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
4811         0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
4812         0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15,
4813         0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x16, 0x16, 0x16,
4814         0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
4815         0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
4816         0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
4817         0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
4818         0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
4819         0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
4820         0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
4821         0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
4822         0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16,
4823         0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x17, 0x17, 0x17, 0x17, 0x17,
4824         0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
4825         0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
4826         0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
4827         0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
4828         0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
4829         0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
4830         0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
4831         0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
4832         0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
4833         0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
4834         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
4835         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
4836         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
4837         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
4838         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
4839         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
4840         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
4841         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
4842         0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18,
4843         0x18, 0x18, 0x18, 0x18, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
4844         0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
4845         0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
4846         0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
4847         0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
4848         0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
4849         0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
4850         0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
4851         0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
4852         0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19,
4853         0x19, 0x19, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
4854         0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
4855         0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
4856         0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
4857         0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
4858         0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
4859         0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
4860         0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
4861         0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
4862         0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a, 0x1a,
4863         0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
4864         0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
4865         0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
4866         0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
4867         0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
4868         0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
4869         0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
4870         0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
4871         0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b,
4872         0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1c, 0x1c,
4873         0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
4874         0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
4875         0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
4876         0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
4877         0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
4878         0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
4879         0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
4880         0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
4881         0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c,
4882         0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1c, 0x1d, 0x1d, 0x1d, 0x1d,
4883         0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
4884         0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
4885         0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
4886         0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
4887         0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
4888         0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
4889         0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
4890         0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
4891         0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d,
4892         0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
4893         0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
4894         0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
4895         0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
4896         0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
4897         0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
4898         0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
4899         0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
4900         0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
4901         0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e,
4902         0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
4903         0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
4904         0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
4905         0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
4906         0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
4907         0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
4908         0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
4909         0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
4910         0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
4911         0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f,
4912         0x1f, 0x1f, 0x1f, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
4913         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
4914         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
4915         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
4916         0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
4917         0x20, 0x20, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
4918         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
4919         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
4920         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
4921         0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
4922         0x21, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
4923         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
4924         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
4925         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
4926         0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22,
4927         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
4928         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
4929         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
4930         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
4931         0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x24,
4932         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
4933         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
4934         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
4935         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24,
4936         0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x24, 0x25, 0x25,
4937         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
4938         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
4939         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
4940         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
4941         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x26, 0x26, 0x26,
4942         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
4943         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
4944         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
4945         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26,
4946         0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x27, 0x27, 0x27, 0x27,
4947         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
4948         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
4949         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
4950         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27,
4951         0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x27, 0x28, 0x28, 0x28, 0x28, 0x28,
4952         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
4953         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
4954         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
4955         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28,
4956         0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
4957         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
4958         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
4959         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
4960         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x29,
4961         0x29, 0x29, 0x29, 0x29, 0x29, 0x29, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
4962         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
4963         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
4964         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
4965         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2a,
4966         0x2a, 0x2a, 0x2a, 0x2a, 0x2a, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
4967         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
4968         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
4969         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
4970         0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b, 0x2b,
4971         0x2b, 0x2b, 0x2b, 0x2b, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
4972         0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
4973         0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
4974         0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
4975         0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c, 0x2c,
4976         0x2c, 0x2c, 0x2c, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
4977         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
4978         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
4979         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
4980         0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d, 0x2d,
4981         0x2d, 0x2d, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
4982         0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
4983         0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
4984         0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
4985         0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e, 0x2e,
4986         0x2e, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
4987         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
4988         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
4989         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
4990         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
4991         0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
4992         0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
4993         0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
4994         0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31,
4995         0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x31, 0x32,
4996         0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
4997         0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
4998         0x32, 0x32, 0x32, 0x32, 0x32, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
4999         0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33,
5000         0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x34, 0x34,
5001         0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
5002         0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
5003         0x34, 0x34, 0x34, 0x34, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
5004         0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35,
5005         0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x35, 0x36, 0x36, 0x36,
5006         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
5007         0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36,
5008         0x36, 0x36, 0x36, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
5009         0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37,
5010         0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x37, 0x38, 0x38, 0x38, 0x38,
5011         0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
5012         0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38, 0x38,
5013         0x38, 0x38, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
5014         0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39,
5015         0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x39, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
5016         0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
5017         0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a, 0x3a,
5018         0x3a, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
5019         0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b,
5020         0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3b, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
5021         0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
5022         0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c,
5023         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
5024         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d,
5025         0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3d, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
5026         0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e,
5027         0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3f,
5028         0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
5029         0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
5030         0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
5031         0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x41, 0x41, 0x41, 0x41, 0x41,
5032         0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x42, 0x42,
5033         0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,
5034         0x42, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43, 0x43,
5035         0x43, 0x43, 0x43, 0x43, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44,
5036         0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45,
5037         0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x46, 0x46, 0x46,
5038         0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
5039         0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47,
5040         0x47, 0x47, 0x47, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x48,
5041         0x48, 0x48, 0x48, 0x48, 0x48, 0x48, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49,
5042         0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x4a, 0x4a, 0x4a, 0x4a,
5043         0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4a, 0x4b,
5044         0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b, 0x4b,
5045         0x4b, 0x4b, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4c,
5046         0x4c, 0x4c, 0x4c, 0x4c, 0x4c, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d,
5047         0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e,
5048         0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4e, 0x4f, 0x4f,
5049         0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
5050         0x4f, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x50, 0x51, 0x51, 0x51, 0x51,
5051         0x51, 0x51, 0x51, 0x51, 0x52, 0x52, 0x52, 0x52, 0x52, 0x52, 0x52, 0x52, 0x53,
5052         0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x53, 0x54, 0x54, 0x54, 0x54, 0x54, 0x54,
5053         0x54, 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x56, 0x56, 0x56,
5054         0x56, 0x56, 0x56, 0x56, 0x56, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57, 0x57,
5055         0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x58, 0x59, 0x59, 0x59, 0x59, 0x59,
5056         0x59, 0x59, 0x59, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5a, 0x5b, 0x5b,
5057         0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5b, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c, 0x5c,
5058         0x5c, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5d, 0x5e, 0x5e, 0x5e, 0x5e,
5059         0x5e, 0x5e, 0x5e, 0x5e, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x5f, 0x60,
5060         0x60, 0x60, 0x60, 0x61, 0x61, 0x61, 0x61, 0x62, 0x62, 0x62, 0x62, 0x63, 0x63,
5061         0x63, 0x63, 0x64, 0x64, 0x64, 0x64, 0x65, 0x65, 0x65, 0x65, 0x66, 0x66, 0x66,
5062         0x66, 0x67, 0x67, 0x67, 0x67, 0x68, 0x68, 0x68, 0x68, 0x69, 0x69, 0x69, 0x69,
5063         0x6a, 0x6a, 0x6a, 0x6a, 0x6b, 0x6b, 0x6b, 0x6b, 0x6c, 0x6c, 0x6c, 0x6c, 0x6d,
5064         0x6d, 0x6d, 0x6d, 0x6e, 0x6e, 0x6e, 0x6e, 0x6f, 0x6f, 0x6f, 0x6f, 0x70, 0x70,
5065         0x71, 0x71, 0x72, 0x72, 0x73, 0x73, 0x74, 0x74, 0x75, 0x75, 0x76, 0x76, 0x77,
5066         0x77, 0x78, 0x78, 0x79, 0x79, 0x7a, 0x7a, 0x7b, 0x7b, 0x7c, 0x7c, 0x7d, 0x7d,
5067         0x7e, 0x7e, 0xff, 0xfe, 0xfe, 0xfd, 0xfd, 0xfc, 0xfc, 0xfb, 0xfb, 0xfa, 0xfa,
5068         0xf9, 0xf9, 0xf8, 0xf8, 0xf7, 0xf7, 0xf6, 0xf6, 0xf5, 0xf5, 0xf4, 0xf4, 0xf3,
5069         0xf3, 0xf2, 0xf2, 0xf1, 0xf1, 0xf0, 0xf0, 0xef, 0xef, 0xef, 0xef, 0xee, 0xee,
5070         0xee, 0xee, 0xed, 0xed, 0xed, 0xed, 0xec, 0xec, 0xec, 0xec, 0xeb, 0xeb, 0xeb,
5071         0xeb, 0xea, 0xea, 0xea, 0xea, 0xe9, 0xe9, 0xe9, 0xe9, 0xe8, 0xe8, 0xe8, 0xe8,
5072         0xe7, 0xe7, 0xe7, 0xe7, 0xe6, 0xe6, 0xe6, 0xe6, 0xe5, 0xe5, 0xe5, 0xe5, 0xe4,
5073         0xe4, 0xe4, 0xe4, 0xe3, 0xe3, 0xe3, 0xe3, 0xe2, 0xe2, 0xe2, 0xe2, 0xe1, 0xe1,
5074         0xe1, 0xe1, 0xe0, 0xe0, 0xe0, 0xe0, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf, 0xdf,
5075         0xdf, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xde, 0xdd, 0xdd, 0xdd, 0xdd,
5076         0xdd, 0xdd, 0xdd, 0xdd, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdc, 0xdb,
5077         0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xdb, 0xda, 0xda, 0xda, 0xda, 0xda, 0xda,
5078         0xda, 0xda, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xd9, 0xd8, 0xd8, 0xd8,
5079         0xd8, 0xd8, 0xd8, 0xd8, 0xd8, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7, 0xd7,
5080         0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd6, 0xd5, 0xd5, 0xd5, 0xd5, 0xd5,
5081         0xd5, 0xd5, 0xd5, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd4, 0xd3, 0xd3,
5082         0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd3, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2, 0xd2,
5083         0xd2, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd1, 0xd0, 0xd0, 0xd0, 0xd0,
5084         0xd0, 0xd0, 0xd0, 0xd0, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf,
5085         0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce,
5086         0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xce, 0xcd, 0xcd, 0xcd,
5087         0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
5088         0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc,
5089         0xcc, 0xcc, 0xcc, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb,
5090         0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xcb, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca,
5091         0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xca, 0xc9, 0xc9, 0xc9, 0xc9,
5092         0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc9, 0xc8,
5093         0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8,
5094         0xc8, 0xc8, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc7,
5095         0xc7, 0xc7, 0xc7, 0xc7, 0xc7, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6,
5096         0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5,
5097         0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc4, 0xc4,
5098         0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4, 0xc4,
5099         0xc4, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3,
5100         0xc3, 0xc3, 0xc3, 0xc3, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2,
5101         0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc2, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1,
5102         0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc1, 0xc0, 0xc0, 0xc0,
5103         0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0,
5104         0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
5105         0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
5106         0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
5107         0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe,
5108         0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbe, 0xbd,
5109         0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
5110         0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbd,
5111         0xbd, 0xbd, 0xbd, 0xbd, 0xbd, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
5112         0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc,
5113         0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbc, 0xbb, 0xbb,
5114         0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
5115         0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb, 0xbb,
5116         0xbb, 0xbb, 0xbb, 0xbb, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
5117         0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba,
5118         0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xba, 0xb9, 0xb9, 0xb9,
5119         0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
5120         0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9, 0xb9,
5121         0xb9, 0xb9, 0xb9, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
5122         0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8,
5123         0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb8, 0xb7, 0xb7, 0xb7, 0xb7,
5124         0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
5125         0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7, 0xb7,
5126         0xb7, 0xb7, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
5127         0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6,
5128         0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb6, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
5129         0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
5130         0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5, 0xb5,
5131         0xb5, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
5132         0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4,
5133         0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb4, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
5134         0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
5135         0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3, 0xb3,
5136         0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
5137         0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2,
5138         0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
5139         0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1,
5140         0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb1, 0xb0,
5141         0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
5142         0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xb0,
5143         0xb0, 0xb0, 0xb0, 0xb0, 0xb0, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
5144         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
5145         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
5146         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
5147         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
5148         0xaf, 0xaf, 0xaf, 0xaf, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
5149         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
5150         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
5151         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
5152         0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae, 0xae,
5153         0xae, 0xae, 0xae, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
5154         0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
5155         0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
5156         0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
5157         0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad, 0xad,
5158         0xad, 0xad, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
5159         0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
5160         0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
5161         0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
5162         0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac, 0xac,
5163         0xac, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
5164         0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
5165         0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
5166         0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
5167         0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
5168         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
5169         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
5170         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
5171         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
5172         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xa9,
5173         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
5174         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
5175         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
5176         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9,
5177         0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa9, 0xa8, 0xa8,
5178         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
5179         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
5180         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
5181         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8,
5182         0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa7, 0xa7, 0xa7,
5183         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
5184         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
5185         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
5186         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7,
5187         0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa7, 0xa6, 0xa6, 0xa6, 0xa6,
5188         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
5189         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
5190         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
5191         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6,
5192         0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa6, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
5193         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
5194         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
5195         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
5196         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
5197         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
5198         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
5199         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
5200         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
5201         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4,
5202         0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa4, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
5203         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
5204         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
5205         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
5206         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa3,
5207         0xa3, 0xa3, 0xa3, 0xa3, 0xa3, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
5208         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
5209         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
5210         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
5211         0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2, 0xa2,
5212         0xa2, 0xa2, 0xa2, 0xa2, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
5213         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
5214         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
5215         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
5216         0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1, 0xa1,
5217         0xa1, 0xa1, 0xa1, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
5218         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
5219         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
5220         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
5221         0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0,
5222         0xa0, 0xa0, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
5223         0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
5224         0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
5225         0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
5226         0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
5227         0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
5228         0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
5229         0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
5230         0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
5231         0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f,
5232         0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
5233         0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
5234         0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
5235         0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
5236         0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
5237         0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
5238         0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
5239         0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
5240         0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e,
5241         0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9d, 0x9d,
5242         0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
5243         0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
5244         0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
5245         0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
5246         0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
5247         0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
5248         0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
5249         0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
5250         0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d,
5251         0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9d, 0x9c, 0x9c, 0x9c, 0x9c,
5252         0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
5253         0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
5254         0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
5255         0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
5256         0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
5257         0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
5258         0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
5259         0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
5260         0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c,
5261         0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9c, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
5262         0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
5263         0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
5264         0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
5265         0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
5266         0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
5267         0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
5268         0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
5269         0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
5270         0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9b,
5271         0x9b, 0x9b, 0x9b, 0x9b, 0x9b, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
5272         0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
5273         0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
5274         0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
5275         0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
5276         0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
5277         0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
5278         0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
5279         0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
5280         0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a, 0x9a,
5281         0x9a, 0x9a, 0x9a, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
5282         0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
5283         0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
5284         0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
5285         0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
5286         0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
5287         0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
5288         0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
5289         0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
5290         0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
5291         0x99, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
5292         0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
5293         0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
5294         0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
5295         0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
5296         0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
5297         0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
5298         0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
5299         0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98,
5300         0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x98, 0x97,
5301         0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
5302         0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
5303         0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
5304         0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
5305         0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
5306         0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
5307         0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
5308         0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
5309         0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97,
5310         0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x97, 0x96, 0x96, 0x96,
5311         0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
5312         0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
5313         0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
5314         0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
5315         0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
5316         0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
5317         0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
5318         0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
5319         0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96,
5320         0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x95, 0x95, 0x95, 0x95, 0x95,
5321         0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
5322         0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
5323         0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
5324         0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
5325         0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
5326         0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
5327         0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
5328         0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
5329         0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95,
5330         0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
5331         0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
5332         0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
5333         0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
5334         0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
5335         0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
5336         0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
5337         0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
5338         0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
5339         0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94, 0x94,
5340         0x94, 0x94, 0x94, 0x94, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
5341         0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
5342         0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
5343         0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
5344         0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
5345         0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
5346         0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
5347         0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
5348         0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
5349         0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93, 0x93,
5350         0x93, 0x93, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
5351         0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
5352         0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
5353         0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
5354         0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
5355         0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
5356         0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
5357         0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
5358         0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
5359         0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92, 0x92,
5360         0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
5361         0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
5362         0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
5363         0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
5364         0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
5365         0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
5366         0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
5367         0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
5368         0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91,
5369         0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x91, 0x90, 0x90,
5370         0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5371         0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5372         0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5373         0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5374         0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5375         0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5376         0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5377         0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5378         0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
5379         0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x8f, 0x8f, 0x8f, 0x8f,
5380         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5381         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5382         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5383         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5384         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5385         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5386         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5387         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5388         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5389         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5390         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5391         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5392         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5393         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5394         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5395         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5396         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5397         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5398         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
5399         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5400         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5401         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5402         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5403         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5404         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5405         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5406         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5407         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5408         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5409         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5410         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5411         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5412         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5413         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5414         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5415         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5416         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5417         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5418         0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e, 0x8e,
5419         0x8e, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5420         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5421         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5422         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5423         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5424         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5425         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5426         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5427         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5428         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5429         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5430         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5431         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5432         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5433         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5434         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5435         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5436         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5437         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d,
5438         0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8c, 0x8c, 0x8c,
5439         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5440         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5441         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5442         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5443         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5444         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5445         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5446         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5447         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5448         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5449         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5450         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5451         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5452         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5453         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5454         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5455         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5456         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5457         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c,
5458         0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5459         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5460         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5461         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5462         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5463         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5464         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5465         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5466         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5467         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5468         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5469         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5470         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5471         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5472         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5473         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5474         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5475         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5476         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5477         0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b, 0x8b,
5478         0x8b, 0x8b, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5479         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5480         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5481         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5482         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5483         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5484         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5485         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5486         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5487         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5488         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5489         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5490         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5491         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5492         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5493         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5494         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5495         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5496         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a,
5497         0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x8a, 0x89, 0x89,
5498         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5499         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5500         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5501         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5502         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5503         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5504         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5505         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5506         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5507         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5508         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5509         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5510         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5511         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5512         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5513         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5514         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5515         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5516         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89,
5517         0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x89, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5518         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5519         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5520         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5521         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5522         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5523         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5524         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5525         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5526         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5527         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5528         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5529         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5530         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5531         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5532         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5533         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5534         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5535         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5536         0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
5537         0x88, 0x88, 0x88, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5538         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5539         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5540         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5541         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5542         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5543         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5544         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5545         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5546         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5547         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5548         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5549         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5550         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5551         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5552         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5553         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5554         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5555         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87,
5556         0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, 0x86,
5557         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5558         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5559         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5560         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5561         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5562         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5563         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5564         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5565         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5566         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5567         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5568         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5569         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5570         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5571         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5572         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5573         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5574         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5575         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86,
5576         0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x86, 0x85, 0x85, 0x85, 0x85, 0x85,
5577         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5578         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5579         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5580         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5581         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5582         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5583         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5584         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5585         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5586         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5587         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5588         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5589         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5590         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5591         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5592         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5593         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5594         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5595         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
5596         0x85, 0x85, 0x85, 0x85, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5597         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5598         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5599         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5600         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5601         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5602         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5603         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5604         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5605         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5606         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5607         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5608         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5609         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5610         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5611         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5612         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5613         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5614         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5615         0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84,
5616         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5617         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5618         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5619         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5620         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5621         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5622         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5623         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5624         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5625         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5626         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5627         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5628         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5629         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5630         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5631         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5632         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5633         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5634         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83,
5635         0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x83, 0x82, 0x82, 0x82, 0x82,
5636         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5637         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5638         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5639         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5640         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5641         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5642         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5643         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5644         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5645         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5646         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5647         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5648         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5649         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5650         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5651         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5652         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5653         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5654         0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82,
5655         0x82, 0x82, 0x82, 0x82, 0x82, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5656         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5657         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5658         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5659         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5660         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5661         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5662         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5663         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5664         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5665         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5666         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5667         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5668         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5669         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5670         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5671         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5672         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5673         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5674         0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81,
5675         0x81, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5676         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5677         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5678         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5679         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5680         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5681         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5682         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5683         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5684         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5685         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5686         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5687         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5688         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5689         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5690         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5691         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5692         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5693         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5694         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5695         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5696         0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
5697         0x80, 0x80, 0x80, 0x80
5698     };
5699
5700     return encode[(int)(vol * decode_to_14bits_float[sample]) + ARRAY_SIZE(encode) / 2];
5701 }