diff --git a/project/jni/openal/Android.mk b/project/jni/openal/Android.mk index 9802a2741..53d71f527 100644 --- a/project/jni/openal/Android.mk +++ b/project/jni/openal/Android.mk @@ -9,8 +9,6 @@ APP_SUBDIRS := $(patsubst $(LOCAL_PATH)/%, %, $(shell find $(LOCAL_PATH)/src -ty LOCAL_C_INCLUDES := $(foreach D, $(APP_SUBDIRS), $(LOCAL_PATH)/$(D)) $(LOCAL_PATH)/include LOCAL_CFLAGS := -O3 -DHAVE_CONFIG_H -DAL_ALEXT_PROTOTYPES - - LOCAL_CPP_EXTENSION := .cpp LOCAL_SRC_FILES := $(foreach F, $(APP_SUBDIRS), $(addprefix $(F)/,$(notdir $(wildcard $(LOCAL_PATH)/$(F)/*.cpp)))) @@ -22,4 +20,8 @@ LOCAL_STATIC_LIBRARIES := LOCAL_LDLIBS := -llog +ifneq ($(CRYSTAX_R5_TOOLCHAIN),) +LOCAL_LDLIBS += -L$(NDK_PATH)/sources/crystax/libs/armeabi -lcrystax_static # I have no idea how could OpenAL link to C++ wide-char support lib +endif + include $(BUILD_SHARED_LIBRARY) diff --git a/project/jni/openal/include/AL/alut.h b/project/jni/openal/include/AL/alut.h new file mode 100644 index 000000000..4b05a3cb9 --- /dev/null +++ b/project/jni/openal/include/AL/alut.h @@ -0,0 +1,126 @@ +#if !defined(AL_ALUT_H) +#define AL_ALUT_H + +#if defined(_MSC_VER) +#include +#include +#elif defined(__APPLE__) +#include +#include +#else +#include +#include +#endif + +#if defined(__cplusplus) +extern "C" { +#endif + +#if defined(_WIN32) && !defined(_XBOX) + #if defined (ALUT_BUILD_LIBRARY) + #define ALUT_API __declspec(dllexport) + #else + #define ALUT_API __declspec(dllimport) + #endif +#else + #if defined(ALUT_BUILD_LIBRARY) && defined(HAVE_GCC_VISIBILITY) + #define ALUT_API __attribute__((visibility("default"))) + #else + #define ALUT_API extern + #endif +#endif + +#if defined(_WIN32) + #define ALUT_APIENTRY __cdecl +#else + #define ALUT_APIENTRY +#endif + +#if defined(__MWERKS_) + #pragma export on +#endif + +/* Flag deprecated functions if possible (VisualC++ .NET and GCC >= 3.1.1). */ +#if defined(_MSC_VER) && _MSC_VER >= 1300 && !defined(MIDL_PASS) +#define ALUT_ATTRIBUTE_DEPRECATED __declspec(deprecated) +#elif defined(__GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && (__GNUC_MINOR__ > 1 || (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 1)))) +#define ALUT_ATTRIBUTE_DEPRECATED __attribute__((deprecated)) +#else +#define ALUT_ATTRIBUTE_DEPRECATED +#endif + +#define ALUT_API_MAJOR_VERSION 1 +#define ALUT_API_MINOR_VERSION 1 + +#define ALUT_ERROR_NO_ERROR 0 +#define ALUT_ERROR_OUT_OF_MEMORY 0x200 +#define ALUT_ERROR_INVALID_ENUM 0x201 +#define ALUT_ERROR_INVALID_VALUE 0x202 +#define ALUT_ERROR_INVALID_OPERATION 0x203 +#define ALUT_ERROR_NO_CURRENT_CONTEXT 0x204 +#define ALUT_ERROR_AL_ERROR_ON_ENTRY 0x205 +#define ALUT_ERROR_ALC_ERROR_ON_ENTRY 0x206 +#define ALUT_ERROR_OPEN_DEVICE 0x207 +#define ALUT_ERROR_CLOSE_DEVICE 0x208 +#define ALUT_ERROR_CREATE_CONTEXT 0x209 +#define ALUT_ERROR_MAKE_CONTEXT_CURRENT 0x20A +#define ALUT_ERROR_DESTROY_CONTEXT 0x20B +#define ALUT_ERROR_GEN_BUFFERS 0x20C +#define ALUT_ERROR_BUFFER_DATA 0x20D +#define ALUT_ERROR_IO_ERROR 0x20E +#define ALUT_ERROR_UNSUPPORTED_FILE_TYPE 0x20F +#define ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE 0x210 +#define ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA 0x211 + +#define ALUT_WAVEFORM_SINE 0x100 +#define ALUT_WAVEFORM_SQUARE 0x101 +#define ALUT_WAVEFORM_SAWTOOTH 0x102 +#define ALUT_WAVEFORM_WHITENOISE 0x103 +#define ALUT_WAVEFORM_IMPULSE 0x104 + +#define ALUT_LOADER_BUFFER 0x300 +#define ALUT_LOADER_MEMORY 0x301 + +ALUT_API ALboolean ALUT_APIENTRY alutInit (int *argcp, char **argv); +ALUT_API ALboolean ALUT_APIENTRY alutInitWithoutContext (int *argcp, char **argv); +ALUT_API ALboolean ALUT_APIENTRY alutExit (void); + +ALUT_API ALenum ALUT_APIENTRY alutGetError (void); +ALUT_API const char *ALUT_APIENTRY alutGetErrorString (ALenum error); + +ALUT_API ALuint ALUT_APIENTRY alutCreateBufferFromFile (const char *fileName); +ALUT_API ALuint ALUT_APIENTRY alutCreateBufferFromFileImage (const ALvoid *data, ALsizei length); +ALUT_API ALuint ALUT_APIENTRY alutCreateBufferHelloWorld (void); +ALUT_API ALuint ALUT_APIENTRY alutCreateBufferWaveform (ALenum waveshape, ALfloat frequency, ALfloat phase, ALfloat duration); + +ALUT_API ALvoid *ALUT_APIENTRY alutLoadMemoryFromFile (const char *fileName, ALenum *format, ALsizei *size, ALfloat *frequency); +ALUT_API ALvoid *ALUT_APIENTRY alutLoadMemoryFromFileImage (const ALvoid *data, ALsizei length, ALenum *format, ALsizei *size, ALfloat *frequency); +ALUT_API ALvoid *ALUT_APIENTRY alutLoadMemoryHelloWorld (ALenum *format, ALsizei *size, ALfloat *frequency); +ALUT_API ALvoid *ALUT_APIENTRY alutLoadMemoryWaveform (ALenum waveshape, ALfloat frequency, ALfloat phase, ALfloat duration, ALenum *format, ALsizei *size, ALfloat *freq); + +ALUT_API const char *ALUT_APIENTRY alutGetMIMETypes (ALenum loader); + +ALUT_API ALint ALUT_APIENTRY alutGetMajorVersion (void); +ALUT_API ALint ALUT_APIENTRY alutGetMinorVersion (void); + +ALUT_API ALboolean ALUT_APIENTRY alutSleep (ALfloat duration); + +/* Nasty Compatibility stuff, WARNING: THESE FUNCTIONS ARE STRONGLY DEPRECATED */ +#if defined(__APPLE__) +ALUT_API ALUT_ATTRIBUTE_DEPRECATED void ALUT_APIENTRY alutLoadWAVFile (ALbyte *fileName, ALenum *format, void **data, ALsizei *size, ALsizei *frequency); +ALUT_API ALUT_ATTRIBUTE_DEPRECATED void ALUT_APIENTRY alutLoadWAVMemory (ALbyte *buffer, ALenum *format, void **data, ALsizei *size, ALsizei *frequency); +#else +ALUT_API ALUT_ATTRIBUTE_DEPRECATED void ALUT_APIENTRY alutLoadWAVFile (ALbyte *fileName, ALenum *format, void **data, ALsizei *size, ALsizei *frequency, ALboolean *loop); +ALUT_API ALUT_ATTRIBUTE_DEPRECATED void ALUT_APIENTRY alutLoadWAVMemory (ALbyte *buffer, ALenum *format, void **data, ALsizei *size, ALsizei *frequency, ALboolean *loop); +#endif +ALUT_API ALUT_ATTRIBUTE_DEPRECATED void ALUT_APIENTRY alutUnloadWAV (ALenum format, ALvoid *data, ALsizei size, ALsizei frequency); + +#if defined(__MWERKS_) + #pragma export off +#endif + +#if defined(__cplusplus) +} +#endif + +#endif diff --git a/project/jni/openal/src/config.h b/project/jni/openal/src/config.h index 284cdd644..5ddf8411c 100644 --- a/project/jni/openal/src/config.h +++ b/project/jni/openal/src/config.h @@ -34,6 +34,10 @@ /* Define if we have stdint.h */ #define HAVE_STDINT_H +#define HAVE_NANOSLEEP + +#define HAVE_TIME_H + /* Define if we have the __int64 type */ #define HAVE___INT64 diff --git a/project/jni/openal/src/freealut/README b/project/jni/openal/src/freealut/README new file mode 100644 index 000000000..4aae3ac10 --- /dev/null +++ b/project/jni/openal/src/freealut/README @@ -0,0 +1,13 @@ +The files in this directory contain the code of the ALUT library. They typically +compile to make 'libalut.so' on *nix platforms or to 'alut.dll' for Windows +platforms. + +There is also a header file 'alut.h' in ../include/AL which gets installed into +$(includedir)/AL/alut.h on *nix platforms and someplace else entirely on +Windows platforms. + +The file 'helloworld.wav' is the original voice recording of Steve Baker saying +this immortal phrase. It is converted into a large hexadecimal data block inside +alutWaveform.c - but this file is retained in version control just in case +anyone ever feels like re-doing it. The format is 16bit PCM, 1 channel, 44.1kHz +sample rate. diff --git a/project/jni/openal/src/freealut/alutBufferData.c b/project/jni/openal/src/freealut/alutBufferData.c new file mode 100644 index 000000000..53f3b5eb5 --- /dev/null +++ b/project/jni/openal/src/freealut/alutBufferData.c @@ -0,0 +1,147 @@ +#include "alutInternal.h" + +struct BufferData_struct +{ + ALvoid *data; + size_t length; + ALint numChannels; + ALint bitsPerSample; + ALfloat sampleFrequency; +}; + +BufferData * +_alutBufferDataConstruct (ALvoid *data, size_t length, ALint numChannels, + ALint bitsPerSample, ALfloat sampleFrequency) +{ + BufferData *bufferData = (BufferData *) _alutMalloc (sizeof (BufferData)); + if (bufferData == NULL) + { + return NULL; + } + + bufferData->data = data; + bufferData->length = length; + bufferData->numChannels = numChannels; + bufferData->bitsPerSample = bitsPerSample; + bufferData->sampleFrequency = sampleFrequency; + + return bufferData; +} + +ALboolean +_alutBufferDataDestroy (BufferData *bufferData) +{ + if (bufferData->data != NULL) + { + free (bufferData->data); + } + free (bufferData); + return AL_TRUE; +} + +ALvoid * +_alutBufferDataGetData (const BufferData *bufferData) +{ + return bufferData->data; +} + +void +_alutBufferDataDetachData (BufferData *bufferData) +{ + bufferData->data = NULL; +} + +size_t +_alutBufferDataGetLength (const BufferData *bufferData) +{ + return bufferData->length; +} + +static ALint +getNumChannels (const BufferData *bufferData) +{ + return bufferData->numChannels; +} + +static ALint +getBitsPerSample (const BufferData *bufferData) +{ + return bufferData->bitsPerSample; +} + +ALfloat +_alutBufferDataGetSampleFrequency (const BufferData *bufferData) +{ + return bufferData->sampleFrequency; +} + +/**************************************************************************** + * The utility functions below do not know the internal BufferData + * representation. + ****************************************************************************/ + +ALboolean +_alutGetFormat (const BufferData *bufferData, ALenum *format) +{ + if (!_alutFormatConstruct + (getNumChannels (bufferData), getBitsPerSample (bufferData), format)) + { + _alutSetError (ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE); + return AL_FALSE; + } + return AL_TRUE; +} + +static ALuint +generateBuffer (void) +{ + ALuint buffer; + alGenBuffers (1, &buffer); + if (alGetError () != AL_NO_ERROR) + { + _alutSetError (ALUT_ERROR_GEN_BUFFERS); + return AL_NONE; + } + return buffer; +} + +static ALboolean +passBufferData (BufferData *bufferData, ALuint bid) +{ + ALenum format; + size_t size; + ALfloat frequency; + if (!_alutGetFormat (bufferData, &format)) + { + return AL_FALSE; + } + /* GCC is a bit picky about casting function calls, so we do it in two + steps... */ + size = _alutBufferDataGetLength (bufferData); + frequency = _alutBufferDataGetSampleFrequency (bufferData); + alBufferData (bid, format, _alutBufferDataGetData (bufferData), + (ALsizei) size, (ALsizei) frequency); + if (alGetError () != AL_NO_ERROR) + { + _alutSetError (ALUT_ERROR_BUFFER_DATA); + return AL_FALSE; + } + return AL_TRUE; +} + +ALuint +_alutPassBufferData (BufferData *bufferData) +{ + ALuint buffer = generateBuffer (); + if (buffer == AL_NONE) + { + return AL_NONE; + } + + if (!passBufferData (bufferData, buffer)) + { + return AL_NONE; + } + + return buffer; +} diff --git a/project/jni/openal/src/freealut/alutCodec.c b/project/jni/openal/src/freealut/alutCodec.c new file mode 100644 index 000000000..582fca6e3 --- /dev/null +++ b/project/jni/openal/src/freealut/alutCodec.c @@ -0,0 +1,129 @@ +#include "alutInternal.h" + +ALvoid * +_alutCodecLinear (ALvoid *data, size_t length, ALint numChannels, + ALint bitsPerSample, ALfloat sampleFrequency) +{ + return _alutBufferDataConstruct (data, length, numChannels, bitsPerSample, + sampleFrequency); +} + +ALvoid * +_alutCodecPCM8s (ALvoid *data, size_t length, ALint numChannels, + ALint bitsPerSample, ALfloat sampleFrequency) +{ + int8_t *d = (int8_t *) data; + size_t i; + for (i = 0; i < length; i++) + { + d[i] += (int8_t) 128; + } + return _alutBufferDataConstruct (data, length, numChannels, bitsPerSample, + sampleFrequency); +} + +ALvoid * +_alutCodecPCM16 (ALvoid *data, size_t length, ALint numChannels, + ALint bitsPerSample, ALfloat sampleFrequency) +{ + int16_t *d = (int16_t *) data; + size_t i, l = length / 2; + for (i = 0; i < l; i++) + { + int16_t x = d[i]; + d[i] = ((x << 8) & 0xFF00) | ((x >> 8) & 0x00FF); + } + return _alutBufferDataConstruct (data, length, numChannels, bitsPerSample, + sampleFrequency); +} + +/* + * From: http://www.multimedia.cx/simpleaudio.html#tth_sEc6.1 + */ +static int16_t +mulaw2linear (uint8_t mulawbyte) +{ + static const int16_t exp_lut[8] = { + 0, 132, 396, 924, 1980, 4092, 8316, 16764 + }; + int16_t sign, exponent, mantissa, sample; + mulawbyte = ~mulawbyte; + sign = (mulawbyte & 0x80); + exponent = (mulawbyte >> 4) & 0x07; + mantissa = mulawbyte & 0x0F; + sample = exp_lut[exponent] + (mantissa << (exponent + 3)); + if (sign != 0) + { + sample = -sample; + } + return sample; +} + +ALvoid * +_alutCodecULaw (ALvoid *data, size_t length, ALint numChannels, + ALint bitsPerSample, ALfloat sampleFrequency) +{ + uint8_t *d = (uint8_t *) data; + int16_t *buf = (int16_t *) _alutMalloc (length * 2); + size_t i; + if (buf == NULL) + { + return NULL; + } + for (i = 0; i < length; i++) + { + buf[i] = mulaw2linear (d[i]); + } + free (data); + return _alutBufferDataConstruct (buf, length * 2, numChannels, + bitsPerSample, sampleFrequency); +} + +/* + * From: http://www.multimedia.cx/simpleaudio.html#tth_sEc6.1 + */ +#define SIGN_BIT (0x80) /* Sign bit for a A-law byte. */ +#define QUANT_MASK (0xf) /* Quantization field mask. */ +#define SEG_SHIFT (4) /* Left shift for segment number. */ +#define SEG_MASK (0x70) /* Segment field mask. */ +static int16_t +alaw2linear (uint8_t a_val) +{ + int16_t t, seg; + a_val ^= 0x55; + t = (a_val & QUANT_MASK) << 4; + seg = ((int16_t) a_val & SEG_MASK) >> SEG_SHIFT; + switch (seg) + { + case 0: + t += 8; + break; + case 1: + t += 0x108; + break; + default: + t += 0x108; + t <<= seg - 1; + } + return (a_val & SIGN_BIT) ? t : -t; +} + +ALvoid * +_alutCodecALaw (ALvoid *data, size_t length, ALint numChannels, + ALint bitsPerSample, ALfloat sampleFrequency) +{ + uint8_t *d = (uint8_t *) data; + int16_t *buf = (int16_t *) _alutMalloc (length * 2); + size_t i; + if (buf == NULL) + { + return NULL; + } + for (i = 0; i < length; i++) + { + buf[i] = alaw2linear (d[i]); + } + free (data); + return _alutBufferDataConstruct (buf, length * 2, numChannels, + bitsPerSample, sampleFrequency); +} diff --git a/project/jni/openal/src/freealut/alutError.c b/project/jni/openal/src/freealut/alutError.c new file mode 100644 index 000000000..7f79ca2af --- /dev/null +++ b/project/jni/openal/src/freealut/alutError.c @@ -0,0 +1,94 @@ +#include "alutInternal.h" +#include + +static ALenum lastError = ALUT_ERROR_NO_ERROR; + +void +_alutSetError (ALenum err) +{ + /* print a message to stderr if ALUT_DEBUG environment variable is defined */ + if (getenv ("ALUT_DEBUG")) + { + fprintf (stderr, "ALUT error: %s\n", alutGetErrorString (err)); + } + + if (lastError == ALUT_ERROR_NO_ERROR) + { + lastError = err; + } +} + +ALenum +alutGetError (void) +{ + ALint ret = lastError; + lastError = ALUT_ERROR_NO_ERROR; + return ret; +} + +const char * +alutGetErrorString (ALenum error) +{ + switch (error) + { + case ALUT_ERROR_NO_ERROR: + return "No ALUT error found"; + + case ALUT_ERROR_OUT_OF_MEMORY: + return "ALUT ran out of memory"; + + case ALUT_ERROR_INVALID_ENUM: + return "ALUT was given an invalid enumeration token"; + + case ALUT_ERROR_INVALID_VALUE: + return "ALUT was given an invalid value"; + + case ALUT_ERROR_INVALID_OPERATION: + return "The operation was invalid in the current ALUT state"; + + case ALUT_ERROR_NO_CURRENT_CONTEXT: + return "There is no current AL context"; + + case ALUT_ERROR_AL_ERROR_ON_ENTRY: + return "There was already an AL error on entry to an ALUT function"; + + case ALUT_ERROR_ALC_ERROR_ON_ENTRY: + return "There was already an ALC error on entry to an ALUT function"; + + case ALUT_ERROR_OPEN_DEVICE: + return "There was an error opening the ALC device"; + + case ALUT_ERROR_CLOSE_DEVICE: + return "There was an error closing the ALC device"; + + case ALUT_ERROR_CREATE_CONTEXT: + return "There was an error creating an ALC context"; + + case ALUT_ERROR_MAKE_CONTEXT_CURRENT: + return "Could not change the current ALC context"; + + case ALUT_ERROR_DESTROY_CONTEXT: + return "There was an error destroying the ALC context"; + + case ALUT_ERROR_GEN_BUFFERS: + return "There was an error generating an AL buffer"; + + case ALUT_ERROR_BUFFER_DATA: + return "There was an error passing buffer data to AL"; + + case ALUT_ERROR_IO_ERROR: + return "I/O error"; + + case ALUT_ERROR_UNSUPPORTED_FILE_TYPE: + return "Unsupported file type"; + + case ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE: + return "Unsupported mode within an otherwise usable file type"; + + case ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA: + return "The sound data was corrupt or truncated"; + + default: + return "An impossible ALUT error condition was reported?!?"; + } +} diff --git a/project/jni/openal/src/freealut/alutInit.c b/project/jni/openal/src/freealut/alutInit.c new file mode 100644 index 000000000..b41363106 --- /dev/null +++ b/project/jni/openal/src/freealut/alutInit.c @@ -0,0 +1,158 @@ +#include "alutInternal.h" + +static enum +{ + Unintialized, /* ALUT has not been initialized yet or has been de-initialised */ + ALUTDeviceAndContext, /* alutInit has been called successfully */ + ExternalDeviceAndContext /* alutInitWithoutContext has been called */ +} initialisationState = Unintialized; + +/* + * Note: alutContext contains something valid only when initialisationState + * contains ALUTDeviceAndContext. + */ +static ALCcontext *alutContext; + +ALboolean +_alutSanityCheck (void) +{ + ALCcontext *context; + + if (initialisationState == Unintialized) + { + _alutSetError (ALUT_ERROR_INVALID_OPERATION); + return AL_FALSE; + } + + context = alcGetCurrentContext (); + if (context == NULL) + { + _alutSetError (ALUT_ERROR_NO_CURRENT_CONTEXT); + return AL_FALSE; + } + + if (alGetError () != AL_NO_ERROR) + { + _alutSetError (ALUT_ERROR_AL_ERROR_ON_ENTRY); + return AL_FALSE; + } + + if (alcGetError (alcGetContextsDevice (context)) != ALC_NO_ERROR) + { + _alutSetError (ALUT_ERROR_ALC_ERROR_ON_ENTRY); + return AL_FALSE; + } + + return AL_TRUE; +} + +ALboolean +alutInit (int *argcp, char **argv) +{ + ALCdevice *device; + ALCcontext *context; + + if (initialisationState != Unintialized) + { + _alutSetError (ALUT_ERROR_INVALID_OPERATION); + return AL_FALSE; + } + + if ((argcp == NULL) != (argv == NULL)) + { + _alutSetError (ALUT_ERROR_INVALID_VALUE); + return AL_FALSE; + } + + device = alcOpenDevice (NULL); + if (device == NULL) + { + _alutSetError (ALUT_ERROR_OPEN_DEVICE); + return AL_FALSE; + } + + context = alcCreateContext (device, NULL); + if (context == NULL) + { + alcCloseDevice (device); + _alutSetError (ALUT_ERROR_CREATE_CONTEXT); + return AL_FALSE; + } + + if (!alcMakeContextCurrent (context)) + { + alcDestroyContext (context); + alcCloseDevice (device); + _alutSetError (ALUT_ERROR_MAKE_CONTEXT_CURRENT); + return AL_FALSE; + } + + initialisationState = ALUTDeviceAndContext; + alutContext = context; + return AL_TRUE; +} + +ALboolean +alutInitWithoutContext (int *argcp, char **argv) +{ + if (initialisationState != Unintialized) + { + _alutSetError (ALUT_ERROR_INVALID_OPERATION); + return AL_FALSE; + } + + if ((argcp == NULL) != (argv == NULL)) + { + _alutSetError (ALUT_ERROR_INVALID_VALUE); + return AL_FALSE; + } + + initialisationState = ExternalDeviceAndContext; + return AL_TRUE; +} + +ALboolean +alutExit (void) +{ + ALCdevice *device; + + if (initialisationState == Unintialized) + { + _alutSetError (ALUT_ERROR_INVALID_OPERATION); + return AL_FALSE; + } + + if (initialisationState == ExternalDeviceAndContext) + { + initialisationState = Unintialized; + return AL_TRUE; + } + + if (!_alutSanityCheck ()) + { + return AL_FALSE; + } + + if (!alcMakeContextCurrent (NULL)) + { + _alutSetError (ALUT_ERROR_MAKE_CONTEXT_CURRENT); + return AL_FALSE; + } + + device = alcGetContextsDevice (alutContext); + alcDestroyContext (alutContext); + if (alcGetError (device) != ALC_NO_ERROR) + { + _alutSetError (ALUT_ERROR_DESTROY_CONTEXT); + return AL_FALSE; + } + + if (!alcCloseDevice (device)) + { + _alutSetError (ALUT_ERROR_CLOSE_DEVICE); + return AL_FALSE; + } + + initialisationState = Unintialized; + return AL_TRUE; +} diff --git a/project/jni/openal/src/freealut/alutInputStream.c b/project/jni/openal/src/freealut/alutInputStream.c new file mode 100644 index 000000000..1ec7625f4 --- /dev/null +++ b/project/jni/openal/src/freealut/alutInputStream.c @@ -0,0 +1,249 @@ +#include "alutInternal.h" +#include +#include +#include +#include + +#if HAVE_STAT +#if HAVE_UNISTD_H +#include +#endif +#define structStat struct stat +#elif HAVE__STAT +#define stat(p,b) _stat((p),(b)) +#define structStat struct _stat +#else +#error No stat-like function on this platform +#endif + +struct InputStream_struct +{ + ALboolean isFileStream; + char *fileName; + size_t remainingLength; + union + { + FILE *fileDescriptor; /* for file streams */ + const ALvoid *data; /* for memory streams */ + } u; +}; + +/**************************************************************************** + * The functions below know the internal InputStream representation. + ****************************************************************************/ + +InputStream * +_alutInputStreamConstructFromFile (const char *fileName) +{ + InputStream *stream; + structStat statBuf; + FILE *fileDescriptor; + char *fileNameBuffer; + + stream = (InputStream *) _alutMalloc (sizeof (InputStream)); + if (stream == NULL) + { + return NULL; + } + + if (stat (fileName, &statBuf)) + { + _alutSetError (ALUT_ERROR_IO_ERROR); + free (stream); + return NULL; + } + + fileDescriptor = fopen (fileName, "rb"); + if (fileDescriptor == NULL) + { + _alutSetError (ALUT_ERROR_IO_ERROR); + free (stream); + return NULL; + } + + fileNameBuffer = (char *) _alutMalloc (strlen (fileName) + 1); + if (fileNameBuffer == NULL) + { + free (stream); + return NULL; + } + + stream->isFileStream = AL_TRUE; + stream->fileName = strcpy (fileNameBuffer, fileName); + stream->remainingLength = statBuf.st_size; + stream->u.fileDescriptor = fileDescriptor; + return stream; +} + +InputStream * +_alutInputStreamConstructFromMemory (const ALvoid *data, size_t length) +{ + InputStream *stream = (InputStream *) _alutMalloc (sizeof (InputStream)); + if (stream == NULL) + { + return NULL; + } + + stream->isFileStream = AL_FALSE; + stream->fileName = NULL; + stream->remainingLength = length; + stream->u.data = data; + return stream; +} + +ALboolean +_alutInputStreamDestroy (InputStream *stream) +{ + ALboolean status = + (stream->isFileStream && fclose (stream->u.fileDescriptor)) ? + AL_FALSE : AL_TRUE; + if (stream->fileName) + { + free (stream->fileName); + } + free (stream); + return status; +} + +const char * +_alutInputStreamGetFileName (const InputStream *stream) +{ + return stream->fileName; +} + +size_t +_alutInputStreamGetRemainingLength (const InputStream *stream) +{ + return stream->remainingLength; +} + +ALboolean +_alutInputStreamEOF (InputStream *stream) +{ + if (stream->isFileStream) + { + int c = fgetc (stream->u.fileDescriptor); + if (c != EOF) + { + ungetc (c, stream->u.fileDescriptor); + } + return (c == EOF) ? AL_TRUE : AL_FALSE; + } + else + { + return (stream->remainingLength == 0) ? AL_TRUE : AL_FALSE; + } +} + +static ALboolean +streamRead (InputStream *stream, void *ptr, size_t numBytesToRead) +{ + if (stream->isFileStream) + { + size_t numBytesRead = + fread (ptr, 1, numBytesToRead, stream->u.fileDescriptor); + if (numBytesToRead != numBytesRead) + { + _alutSetError (ferror (stream->u.fileDescriptor) ? + ALUT_ERROR_IO_ERROR : + ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA); + return AL_FALSE; + } + return AL_TRUE; + } + else + { + if (stream->remainingLength < numBytesToRead) + { + _alutSetError (ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA); + return AL_FALSE; + } + memcpy (ptr, stream->u.data, numBytesToRead); + stream->u.data = ((const char *) (stream->u.data) + numBytesToRead); + return AL_TRUE; + } +} + +/**************************************************************************** + * The utility functions below do not know the internal InputStream + * representation. + ****************************************************************************/ + +ALvoid * +_alutInputStreamRead (InputStream *stream, size_t length) +{ + ALvoid *data = _alutMalloc (length); + if (data == NULL) + { + return NULL; + } + + if (!streamRead (stream, data, length)) + { + free (data); + return NULL; + } + + return data; +} + +ALboolean +_alutInputStreamSkip (InputStream *stream, size_t numBytesToSkip) +{ + ALboolean status; + char *buf; + if (numBytesToSkip == 0) + { + return AL_TRUE; + } + buf = (char *) _alutMalloc (numBytesToSkip); + if (buf == NULL) + { + return AL_FALSE; + } + status = streamRead (stream, buf, numBytesToSkip); + free (buf); + return status; +} + +ALboolean +_alutInputStreamReadUInt16LE (InputStream *stream, UInt16LittleEndian *value) +{ + unsigned char buf[2]; + if (!streamRead (stream, buf, sizeof (buf))) + { + return AL_FALSE; + } + *value = ((UInt16LittleEndian) buf[1] << 8) | ((UInt16LittleEndian) buf[0]); + return AL_TRUE; +} + +ALboolean +_alutInputStreamReadInt32BE (InputStream *stream, Int32BigEndian *value) +{ + unsigned char buf[4]; + if (!streamRead (stream, buf, sizeof (buf))) + { + return AL_FALSE; + } + *value = + ((Int32BigEndian) buf[0] << 24) | + ((Int32BigEndian) buf[1] << 16) | + ((Int32BigEndian) buf[2] << 8) | ((Int32BigEndian) buf[3]); + return AL_TRUE; +} + +ALboolean +_alutInputStreamReadUInt32LE (InputStream *stream, UInt32LittleEndian *value) +{ + unsigned char buf[4]; + if (!streamRead (stream, buf, sizeof (buf))) + { + return AL_FALSE; + } + *value = + ((UInt32LittleEndian) buf[3] << 24) | + ((UInt32LittleEndian) buf[2] << 16) | + ((UInt32LittleEndian) buf[1] << 8) | ((UInt32LittleEndian) buf[0]); + return AL_TRUE; +} diff --git a/project/jni/openal/src/freealut/alutInternal.h b/project/jni/openal/src/freealut/alutInternal.h new file mode 100644 index 000000000..638db5a1e --- /dev/null +++ b/project/jni/openal/src/freealut/alutInternal.h @@ -0,0 +1,139 @@ +/* + * This file should be #included as the first header in all *.c files. + */ + +#if !defined(ALUT_INTERNAL_H) +#define ALUT_INTERNAL_H + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#ifdef HAVE_STDINT_H +#include +#elif _MSC_VER < 1300 +typedef char int8_t; +typedef unsigned char uint8_t; +typedef short int16_t; +typedef unsigned short uint16_t; +typedef int int32_t; +typedef unsigned int uint32_t; +#elif HAVE_BASETSD_H +#include +typedef INT8 int8_t; +typedef UINT8 uint8_t; +typedef INT16 int16_t; +typedef UINT16 uint16_t; +typedef INT32 int32_t; +typedef UINT32 uint32_t; +#else +#error Do not know sized types on this platform +#endif + +typedef int16_t Int16BigEndian; +typedef uint16_t UInt16LittleEndian; +typedef int32_t Int32BigEndian; +typedef uint32_t UInt32LittleEndian; + +#if HAVE___ATTRIBUTE__ +#define UNUSED(x) x __attribute__((unused)) +#else +#define UNUSED(x) x +#endif + +#include + +#define AU_HEADER_SIZE 24 + +/* see: http://en.wikipedia.org/wiki/Au_file_format, G.72x are missing */ +enum AUEncoding +{ + AU_ULAW_8 = 1, /* 8-bit ISDN u-law */ + AU_PCM_8 = 2, /* 8-bit linear PCM (signed) */ + AU_PCM_16 = 3, /* 16-bit linear PCM (signed, big-endian) */ + AU_PCM_24 = 4, /* 24-bit linear PCM */ + AU_PCM_32 = 5, /* 32-bit linear PCM */ + AU_FLOAT_32 = 6, /* 32-bit IEEE floating point */ + AU_FLOAT_64 = 7, /* 64-bit IEEE floating point */ + AU_ALAW_8 = 27 /* 8-bit ISDN a-law */ +}; + +/* in alutCodec.c */ +typedef ALvoid *Codec (ALvoid *data, size_t length, ALint numChannels, + ALint bitsPerSample, ALfloat sampleFrequency); +extern Codec _alutCodecLinear; +extern Codec _alutCodecPCM8s; +extern Codec _alutCodecPCM16; +extern Codec _alutCodecULaw; +extern Codec _alutCodecALaw; + +/* in alutError.c */ +extern void _alutSetError (ALenum err); + +/* in alutInit.c */ +extern ALboolean _alutSanityCheck (void); + +/* in alutInputStream.c */ +typedef struct InputStream_struct InputStream; +extern InputStream *_alutInputStreamConstructFromFile (const char *fileName); +extern InputStream *_alutInputStreamConstructFromMemory (const ALvoid *data, + size_t length); +extern const char *_alutInputStreamGetFileName (const InputStream *stream); +extern size_t _alutInputStreamGetRemainingLength (const InputStream *stream); +extern ALboolean _alutInputStreamDestroy (InputStream *stream); +extern ALboolean _alutInputStreamEOF (InputStream *stream); +extern ALvoid *_alutInputStreamRead (InputStream *stream, size_t length); +extern ALboolean _alutInputStreamSkip (InputStream *stream, + size_t numBytesToSkip); +extern ALboolean _alutInputStreamReadUInt16LE (InputStream *stream, + UInt16LittleEndian *value); +extern ALboolean _alutInputStreamReadInt32BE (InputStream *stream, + Int32BigEndian *value); +extern ALboolean _alutInputStreamReadUInt32LE (InputStream *stream, + UInt32LittleEndian *value); + +/* in alutLoader.c */ +extern ALuint _alutCreateBufferFromInputStream (InputStream *stream); +extern void *_alutLoadMemoryFromInputStream (InputStream *stream, + ALenum *format, ALsizei *size, + ALfloat *frequency); + +/* in alutOutputStream.c */ +typedef struct OutputStream_struct OutputStream; +extern OutputStream *_alutOutputStreamConstruct (size_t maximumLength); +extern ALboolean _alutOutputStreamDestroy (OutputStream *stream); +extern void *_alutOutputStreamGetData (OutputStream *stream); +extern size_t _alutOutputStreamGetLength (OutputStream *stream); +extern ALboolean _alutOutputStreamWriteInt16BE (OutputStream *stream, + Int16BigEndian value); +extern ALboolean _alutOutputStreamWriteInt32BE (OutputStream *stream, + Int32BigEndian value); + +/* in alutUtil.c */ +extern ALvoid *_alutMalloc (size_t size); +extern ALboolean _alutFormatConstruct (ALint numChannels, ALint bitsPerSample, + ALenum *format); +extern ALboolean _alutFormatGetNumChannels (ALenum format, + ALint *numChannels); +extern ALboolean _alutFormatGetBitsPerSample (ALenum format, + ALint *bitsPerSample); + +/* in alutWaveform.c */ +typedef struct BufferData_struct BufferData; +extern BufferData *_alutBufferDataConstruct (ALvoid *data, size_t length, + ALint numChannels, + ALint bitsPerSample, + ALfloat sampleFrequency); +extern ALboolean _alutBufferDataDestroy (BufferData *bufferData); +extern void _alutBufferDataDetachData (BufferData *bufferData); +extern ALvoid *_alutBufferDataGetData (const BufferData *bufferData); +extern size_t _alutBufferDataGetLength (const BufferData *bufferData); +extern ALfloat _alutBufferDataGetSampleFrequency (const BufferData + *bufferData); +extern ALboolean _alutGetFormat (const BufferData *bufferData, + ALenum *format); +extern ALuint _alutPassBufferData (BufferData *bufferData); + +#endif /* not ALUT_INTERNAL_H */ diff --git a/project/jni/openal/src/freealut/alutLoader.c b/project/jni/openal/src/freealut/alutLoader.c new file mode 100644 index 000000000..a70a8fd9f --- /dev/null +++ b/project/jni/openal/src/freealut/alutLoader.c @@ -0,0 +1,526 @@ +#include "alutInternal.h" +#include + +/****************************************************************************/ + +typedef enum +{ + LittleEndian, + BigEndian, + UnknwonEndian /* has anybody still a PDP11? :-) */ +} Endianess; + +/* test from Harbison & Steele, "C - A Reference Manual", section 6.1.2 */ +static Endianess +endianess (void) +{ + union + { + long l; + char c[sizeof (long)]; + } u; + + u.l = 1; + return (u.c[0] == 1) ? LittleEndian : + ((u.c[sizeof (long) - 1] == 1) ? BigEndian : UnknwonEndian); +} + +/****************************************************************************/ + +static int +safeToLower (int c) +{ + return isupper (c) ? tolower (c) : c; +} + +static int +hasSuffixIgnoringCase (const char *string, const char *suffix) +{ + const char *stringPointer = string; + const char *suffixPointer = suffix; + + if (suffix[0] == '\0') + { + return 1; + } + + while (*stringPointer != '\0') + { + stringPointer++; + } + + while (*suffixPointer != '\0') + { + suffixPointer++; + } + + if (stringPointer - string < suffixPointer - suffix) + { + return 0; + } + + while (safeToLower (*--suffixPointer) == safeToLower (*--stringPointer)) + { + if (suffixPointer == suffix) + { + return 1; + } + } + + return 0; +} + +static BufferData * +loadWavFile (InputStream *stream) +{ + ALboolean found_header = AL_FALSE; + UInt32LittleEndian chunkLength; + Int32BigEndian magic; + UInt16LittleEndian audioFormat; + UInt16LittleEndian numChannels; + UInt32LittleEndian sampleFrequency; + UInt32LittleEndian byteRate; + UInt16LittleEndian blockAlign; + UInt16LittleEndian bitsPerSample; + Codec *codec = _alutCodecLinear; + + if (!_alutInputStreamReadUInt32LE (stream, &chunkLength) || + !_alutInputStreamReadInt32BE (stream, &magic)) + { + return NULL; + } + + if (magic != 0x57415645) /* "WAVE" */ + { + _alutSetError (ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE); + return NULL; + } + + while (1) + { + if (!_alutInputStreamReadInt32BE (stream, &magic) || + !_alutInputStreamReadUInt32LE (stream, &chunkLength)) + { + return NULL; + } + + if (magic == 0x666d7420) /* "fmt " */ + { + found_header = AL_TRUE; + + if (chunkLength < 16) + { + _alutSetError (ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA); + return NULL; + } + + if (!_alutInputStreamReadUInt16LE (stream, &audioFormat) || + !_alutInputStreamReadUInt16LE (stream, &numChannels) || + !_alutInputStreamReadUInt32LE (stream, &sampleFrequency) || + !_alutInputStreamReadUInt32LE (stream, &byteRate) || + !_alutInputStreamReadUInt16LE (stream, &blockAlign) || + !_alutInputStreamReadUInt16LE (stream, &bitsPerSample)) + { + return NULL; + } + + if (!_alutInputStreamSkip (stream, chunkLength - 16)) + { + return NULL; + } + + switch (audioFormat) + { + case 1: /* PCM */ + codec = (bitsPerSample == 8 + || endianess () == + LittleEndian) ? _alutCodecLinear : _alutCodecPCM16; + break; + case 7: /* uLaw */ + bitsPerSample *= 2; /* ToDo: ??? */ + codec = _alutCodecULaw; + break; + default: + _alutSetError (ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE); + return NULL; + } + } + else if (magic == 0x64617461) /* "data" */ + { + ALvoid *data; + if (!found_header) + { + /* ToDo: A bit wrong to check here, fmt chunk could come later... */ + _alutSetError (ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA); + return NULL; + } + data = _alutInputStreamRead (stream, chunkLength); + if (data == NULL) + { + return NULL; + } + return codec (data, chunkLength, numChannels, bitsPerSample, + (ALfloat) sampleFrequency); + } + else + { + if (!_alutInputStreamSkip (stream, chunkLength)) + { + return NULL; + } + } + + if ((chunkLength & 1) && !_alutInputStreamEOF (stream) + && !_alutInputStreamSkip (stream, 1)) + { + return NULL; + } + } +} + +static BufferData * +loadAUFile (InputStream *stream) +{ + Int32BigEndian dataOffset; /* byte offset to data part, minimum 24 */ + Int32BigEndian len; /* number of bytes in the data part, -1 = not known */ + Int32BigEndian encoding; /* encoding of the data part, see AUEncoding */ + Int32BigEndian sampleFrequency; /* number of samples per second */ + Int32BigEndian numChannels; /* number of interleaved channels */ + size_t length; + Codec *codec; + char *data; + ALint bitsPerSample; + + if (!_alutInputStreamReadInt32BE (stream, &dataOffset) || + !_alutInputStreamReadInt32BE (stream, &len) || + !_alutInputStreamReadInt32BE (stream, &encoding) || + !_alutInputStreamReadInt32BE (stream, &sampleFrequency) || + !_alutInputStreamReadInt32BE (stream, &numChannels)) + { + return AL_FALSE; + } + + length = (len == -1) ? + (_alutInputStreamGetRemainingLength (stream) - AU_HEADER_SIZE - + dataOffset) : (size_t) len; + + if (! + (dataOffset >= AU_HEADER_SIZE && length > 0 && sampleFrequency >= 1 + && numChannels >= 1)) + { + _alutSetError (ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA); + return AL_FALSE; + } + + if (!_alutInputStreamSkip (stream, dataOffset - AU_HEADER_SIZE)) + { + return AL_FALSE; + } + + switch (encoding) + { + case AU_ULAW_8: + bitsPerSample = 16; + codec = _alutCodecULaw; + break; + case AU_PCM_8: + bitsPerSample = 8; + codec = _alutCodecPCM8s; + break; + case AU_PCM_16: + bitsPerSample = 16; + codec = + (endianess () == BigEndian) ? _alutCodecLinear : _alutCodecPCM16; + break; + case AU_ALAW_8: + bitsPerSample = 16; + codec = _alutCodecALaw; + break; + default: + _alutSetError (ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE); + return AL_FALSE; + } + + data = _alutInputStreamRead (stream, length); + if (data == NULL) + { + return NULL; + } + return codec (data, length, numChannels, bitsPerSample, + (ALfloat) sampleFrequency); +} + +static BufferData * +loadRawFile (InputStream *stream) +{ + size_t length = _alutInputStreamGetRemainingLength (stream); + ALvoid *data = _alutInputStreamRead (stream, length); + if (data == NULL) + { + return NULL; + } + /* Guesses */ + return _alutCodecLinear (data, length, 1, 8, 8000); +} + +static BufferData * +loadFile (InputStream *stream) +{ + const char *fileName; + Int32BigEndian magic; + + /* Raw files have no magic number - so use the fileName extension */ + + fileName = _alutInputStreamGetFileName (stream); + if (fileName != NULL && hasSuffixIgnoringCase (fileName, ".raw")) + { + return loadRawFile (stream); + } + + /* For other file formats, read the quasi-standard four byte magic number */ + if (!_alutInputStreamReadInt32BE (stream, &magic)) + { + return AL_FALSE; + } + + /* Magic number 'RIFF' == Microsoft '.wav' format */ + if (magic == 0x52494646) + { + return loadWavFile (stream); + } + + /* Magic number '.snd' == Sun & Next's '.au' format */ + if (magic == 0x2E736E64) + { + return loadAUFile (stream); + } + + _alutSetError (ALUT_ERROR_UNSUPPORTED_FILE_TYPE); + return AL_FALSE; +} + +ALuint +_alutCreateBufferFromInputStream (InputStream *stream) +{ + BufferData *bufferData; + ALuint buffer; + + if (stream == NULL) + { + return AL_NONE; + } + + bufferData = loadFile (stream); + _alutInputStreamDestroy (stream); + if (bufferData == NULL) + { + return AL_NONE; + } + + buffer = _alutPassBufferData (bufferData); + _alutBufferDataDestroy (bufferData); + + return buffer; +} + +ALuint +alutCreateBufferFromFile (const char *fileName) +{ + InputStream *stream; + if (!_alutSanityCheck ()) + { + return AL_NONE; + } + stream = _alutInputStreamConstructFromFile (fileName); + return _alutCreateBufferFromInputStream (stream); +} + +ALuint +alutCreateBufferFromFileImage (const ALvoid *data, ALsizei length) +{ + InputStream *stream; + if (!_alutSanityCheck ()) + { + return AL_NONE; + } + stream = _alutInputStreamConstructFromMemory (data, length); + return _alutCreateBufferFromInputStream (stream); +} + +void * +_alutLoadMemoryFromInputStream (InputStream *stream, ALenum *format, + ALsizei *size, ALfloat *frequency) +{ + BufferData *bufferData; + ALenum fmt; + void *data; + + if (stream == NULL) + { + return NULL; + } + + bufferData = loadFile (stream); + if (bufferData == NULL) + { + _alutInputStreamDestroy (stream); + return NULL; + } + _alutInputStreamDestroy (stream); + + if (!_alutGetFormat (bufferData, &fmt)) + { + _alutBufferDataDestroy (bufferData); + return NULL; + } + + if (size != NULL) + { + *size = (ALsizei) _alutBufferDataGetLength (bufferData); + } + + if (format != NULL) + { + *format = fmt; + } + + if (frequency != NULL) + { + *frequency = _alutBufferDataGetSampleFrequency (bufferData); + } + + data = _alutBufferDataGetData (bufferData); + _alutBufferDataDetachData (bufferData); + _alutBufferDataDestroy (bufferData); + return data; +} + +ALvoid * +alutLoadMemoryFromFile (const char *fileName, ALenum *format, + ALsizei *size, ALfloat *frequency) +{ + InputStream *stream; + if (!_alutSanityCheck ()) + { + return NULL; + } + stream = _alutInputStreamConstructFromFile (fileName); + return _alutLoadMemoryFromInputStream (stream, format, size, frequency); +} + +ALvoid * +alutLoadMemoryFromFileImage (const ALvoid *data, ALsizei length, + ALenum *format, ALsizei *size, + ALfloat *frequency) +{ + InputStream *stream; + if (!_alutSanityCheck ()) + { + return NULL; + } + stream = _alutInputStreamConstructFromMemory (data, length); + return _alutLoadMemoryFromInputStream (stream, format, size, frequency); +} + +/* + Yukky backwards compatibility crap. +*/ + +void +alutLoadWAVFile (ALbyte *fileName, ALenum *format, void **data, ALsizei *size, + ALsizei *frequency +#if !defined(__APPLE__) + , ALboolean *loop +#endif + ) +{ + InputStream *stream; + ALfloat freq; + + /* Don't do an _alutSanityCheck () because it's not required in ALUT 0.x.x */ + + stream = _alutInputStreamConstructFromFile (fileName); + *data = _alutLoadMemoryFromInputStream (stream, format, size, &freq); + if (*data == NULL) + { + return; + } + + if (frequency) + { + *frequency = (ALsizei) freq; + } + +#if !defined(__APPLE__) + if (loop) + { + *loop = AL_FALSE; + } +#endif +} + +void +alutLoadWAVMemory (ALbyte *buffer, ALenum *format, void **data, ALsizei *size, + ALsizei *frequency +#if !defined(__APPLE__) + , ALboolean *loop +#endif + ) +{ + InputStream *stream; + ALfloat freq; + + /* Don't do an _alutSanityCheck () because it's not required in ALUT 0.x.x */ + + /* ToDo: Can we do something less insane than passing 0x7FFFFFFF? */ + stream = _alutInputStreamConstructFromMemory (buffer, 0x7FFFFFFF); + _alutLoadMemoryFromInputStream (stream, format, size, &freq); + if (*data == NULL) + { + return; + } + + if (frequency) + { + *frequency = (ALsizei) freq; + } + +#if !defined(__APPLE__) + if (loop) + { + *loop = AL_FALSE; + } +#endif +} + +void +alutUnloadWAV (ALenum UNUSED (format), ALvoid *data, ALsizei UNUSED (size), + ALsizei UNUSED (frequency)) +{ + /* Don't do an _alutSanityCheck () because it's not required in ALUT 0.x.x */ + + free (data); +} + +const char * +alutGetMIMETypes (ALenum loader) +{ + if (!_alutSanityCheck ()) + { + return NULL; + } + + /* We do not distinguish the loaders yet... */ + switch (loader) + { + case ALUT_LOADER_BUFFER: + return "audio/basic,audio/x-raw,audio/x-wav"; + + case ALUT_LOADER_MEMORY: + return "audio/basic,audio/x-raw,audio/x-wav"; + + default: + _alutSetError (ALUT_ERROR_INVALID_ENUM); + return NULL; + } +} diff --git a/project/jni/openal/src/freealut/alutOutputStream.c b/project/jni/openal/src/freealut/alutOutputStream.c new file mode 100644 index 000000000..77458f280 --- /dev/null +++ b/project/jni/openal/src/freealut/alutOutputStream.c @@ -0,0 +1,93 @@ +#include "alutInternal.h" +#include + +struct OutputStream_struct +{ + char *data; + char *current; + size_t maximumLength; +}; + +/**************************************************************************** + * The functions below know the internal OutputStream representation. + ****************************************************************************/ + +OutputStream * +_alutOutputStreamConstruct (size_t maximumLength) +{ + OutputStream *stream = (OutputStream *) _alutMalloc (sizeof (OutputStream)); + if (stream == NULL) + { + return NULL; + } + stream->data = _alutMalloc (maximumLength); + if (stream->data == NULL) + { + free (stream); + return NULL; + } + stream->current = stream->data; + stream->maximumLength = maximumLength; + return stream; +} + +ALboolean +_alutOutputStreamDestroy (OutputStream *stream) +{ + free (stream->data); + free (stream); + return AL_TRUE; +} + +void * +_alutOutputStreamGetData (OutputStream *stream) +{ + return stream->data; +} + +size_t +_alutOutputStreamGetLength (OutputStream *stream) +{ + return stream->current - stream->data; +} + +static ALboolean +streamWrite (OutputStream *stream, const void *ptr, size_t numBytesToWrite) +{ + size_t remainingLength = + stream->maximumLength - _alutOutputStreamGetLength (stream); + if (remainingLength < numBytesToWrite) + { + /* this should never happen within our library */ + _alutSetError (ALUT_ERROR_IO_ERROR); + return AL_FALSE; + } + memcpy (stream->current, ptr, numBytesToWrite); + stream->current += numBytesToWrite; + return AL_TRUE; +} + +/**************************************************************************** + * The utility functions below do not know the internal OutputStream + * representation. + ****************************************************************************/ + +ALboolean +_alutOutputStreamWriteInt16BE (OutputStream *stream, Int16BigEndian value) +{ + unsigned char buf[2]; + buf[0] = (unsigned char) (value >> 8); + buf[1] = (unsigned char) value; + return streamWrite (stream, buf, 2); +} + +ALboolean +_alutOutputStreamWriteInt32BE (OutputStream *stream, Int32BigEndian value) +{ + unsigned char buf[4]; + buf[0] = (unsigned char) (value >> 24); + buf[1] = (unsigned char) (value >> 16); + buf[2] = (unsigned char) (value >> 8); + buf[3] = (unsigned char) value; + return streamWrite (stream, buf, 4); +} diff --git a/project/jni/openal/src/freealut/alutUtil.c b/project/jni/openal/src/freealut/alutUtil.c new file mode 100644 index 000000000..285385c7a --- /dev/null +++ b/project/jni/openal/src/freealut/alutUtil.c @@ -0,0 +1,144 @@ +#include "alutInternal.h" + +#if defined(HAVE_NANOSLEEP) && defined(HAVE_TIME_H) +#include +#include +#elif HAVE_USLEEP && HAVE_UNISTD_H +#include +#elif HAVE_SLEEP && HAVE_WINDOWS_H +#include +#else +#error No way to sleep on this platform +#endif + +ALboolean +alutSleep (ALfloat duration) +{ + if (duration < 0) + { + _alutSetError (ALUT_ERROR_INVALID_VALUE); + return AL_FALSE; + } + + { + ALuint seconds = (ALuint) duration; + ALfloat rest = duration - (ALfloat) seconds; + +#if defined(HAVE_NANOSLEEP) && defined(HAVE_TIME_H) + + ALuint microSecs = (ALuint) (rest * 1000000); + struct timespec t, remainingTime; + t.tv_sec = (time_t) seconds; + t.tv_nsec = ((long) microSecs) * 1000; + + /* At least the interaction of nanosleep and signals is specified! */ + while (nanosleep (&t, &remainingTime) < 0) + { + if (errno != EINTR) + { + return AL_FALSE; + } + /* If we received a signal, let's try again with the remaining time. */ + t.tv_sec = remainingTime.tv_sec; + t.tv_nsec = remainingTime.tv_nsec; + } + +#elif HAVE_USLEEP && HAVE_UNISTD_H + + while (seconds > 0) + { + usleep (1000000); + seconds--; + } + usleep ((unsigned int) (rest * 1000000)); + +#elif HAVE_SLEEP && HAVE_WINDOWS_H + + while (seconds > 0) + { + Sleep (1000); + seconds--; + } + Sleep ((DWORD) (rest * 1000)); + +#endif + + } + return AL_TRUE; +} + +ALvoid * +_alutMalloc (size_t size) +{ + ALvoid *ptr = malloc (size == 0 ? 1 : size); + if (ptr == NULL) + { + _alutSetError (ALUT_ERROR_OUT_OF_MEMORY); + } + return ptr; +} + +ALboolean +_alutFormatConstruct (ALint numChannels, ALint bitsPerSample, ALenum *format) +{ + switch (numChannels) + { + case 1: + switch (bitsPerSample) + { + case 8: + *format = AL_FORMAT_MONO8; + return AL_TRUE; + case 16: + *format = AL_FORMAT_MONO16; + return AL_TRUE; + } + break; + case 2: + switch (bitsPerSample) + { + case 8: + *format = AL_FORMAT_STEREO8; + return AL_TRUE; + case 16: + *format = AL_FORMAT_STEREO16; + return AL_TRUE; + } + break; + } + return AL_FALSE; +} + +ALboolean +_alutFormatGetNumChannels (ALenum format, ALint *numChannels) +{ + switch (format) + { + case AL_FORMAT_MONO8: + case AL_FORMAT_MONO16: + *numChannels = 1; + return AL_TRUE; + case AL_FORMAT_STEREO8: + case AL_FORMAT_STEREO16: + *numChannels = 2; + return AL_TRUE; + } + return AL_FALSE; +} + +ALboolean +_alutFormatGetBitsPerSample (ALenum format, ALint *bitsPerSample) +{ + switch (format) + { + case AL_FORMAT_MONO8: + case AL_FORMAT_STEREO8: + *bitsPerSample = 8; + return AL_TRUE; + case AL_FORMAT_MONO16: + case AL_FORMAT_STEREO16: + *bitsPerSample = 16; + return AL_TRUE; + } + return AL_FALSE; +} diff --git a/project/jni/openal/src/freealut/alutVersion.c b/project/jni/openal/src/freealut/alutVersion.c new file mode 100644 index 000000000..d392892b6 --- /dev/null +++ b/project/jni/openal/src/freealut/alutVersion.c @@ -0,0 +1,13 @@ +#include "alutInternal.h" + +ALint +alutGetMajorVersion (void) +{ + return ALUT_API_MAJOR_VERSION; +} + +ALint +alutGetMinorVersion (void) +{ + return ALUT_API_MINOR_VERSION; +} diff --git a/project/jni/openal/src/freealut/alutWaveform.c b/project/jni/openal/src/freealut/alutWaveform.c new file mode 100644 index 000000000..5327f8606 --- /dev/null +++ b/project/jni/openal/src/freealut/alutWaveform.c @@ -0,0 +1,938 @@ +#include "alutInternal.h" +#include +#include + +#if defined(_WIN32) +#define random() rand() +#endif + +static const double sampleFrequency = 44100; + +/* + * The following waveformFoo functions expect the phase of the previous call and + * the current phase, both in the range [0..+1). They return an amplitude in the + * range [-1..+1]. + */ + +typedef double (*waveformFunction) (double lastPhase, double phase); + +static double +waveformSine (double UNUSED (lastPhase), double phase) +{ + static const double pi = 3.14159265358979323846; + return sin (phase * pi); +} + +static double +waveformSquare (double UNUSED (lastPhase), double phase) +{ + return (phase >= 0.5) ? -1 : 1; +} + +static double +waveformSawtooth (double UNUSED (lastPhase), double phase) +{ + return 2 * phase - 1; +} + +static double +waveformWhitenoise (double UNUSED (lastPhase), double UNUSED (phase)) +{ + static const long prime = 67867967L; + return 2 * (double) (random () % prime) / prime - 1; +} + +static double +waveformImpulse (double lastPhase, double phase) +{ + return (lastPhase > phase) ? 1 : 0; +} + +static waveformFunction +getWaveformFunction (ALenum waveshape) +{ + switch (waveshape) + { + case ALUT_WAVEFORM_SINE: + return &waveformSine; + case ALUT_WAVEFORM_SQUARE: + return &waveformSquare; + case ALUT_WAVEFORM_SAWTOOTH: + return &waveformSawtooth; + case ALUT_WAVEFORM_WHITENOISE: + return &waveformWhitenoise; + case ALUT_WAVEFORM_IMPULSE: + return &waveformImpulse; + } + _alutSetError (ALUT_ERROR_INVALID_ENUM); + return NULL; +} + +static OutputStream * +generateWaveform (ALenum waveshape, ALfloat frequency, ALfloat phase, + ALfloat duration) +{ + waveformFunction func; + double sampleDuration, lastPhase, numSamplesD; + size_t numBytes, numSamples, i; + OutputStream *stream; + + func = getWaveformFunction (waveshape); + if (func == NULL) + { + return NULL; + } + + /* ToDo: Shall we test phase for [-180 .. +180]? */ + if (frequency <= 0 || duration < 0) + { + _alutSetError (ALUT_ERROR_INVALID_VALUE); + return NULL; + } + + /* allocate stream to hold AU header and sample data */ + sampleDuration = floor ((frequency * duration) + 0.5) / frequency; + /* GCC is a bit picky about casting function calls, so we do it in two + steps... */ + numSamplesD = floor (sampleDuration * sampleFrequency); + numSamples = (size_t) numSamplesD; + numBytes = numSamples * sizeof (int16_t); + stream = _alutOutputStreamConstruct (AU_HEADER_SIZE + numBytes); + if (stream == NULL) + { + return NULL; + } + + /* write AU header for our 16bit mono data */ + if (!_alutOutputStreamWriteInt32BE (stream, 0x2e736e64) || /* ".snd" */ + !_alutOutputStreamWriteInt32BE (stream, AU_HEADER_SIZE) || + !_alutOutputStreamWriteInt32BE (stream, (Int32BigEndian) numBytes) || + !_alutOutputStreamWriteInt32BE (stream, AU_PCM_16) || + !_alutOutputStreamWriteInt32BE (stream, + (Int32BigEndian) sampleFrequency) || + !_alutOutputStreamWriteInt32BE (stream, 1)) + { + _alutOutputStreamDestroy (stream); + return NULL; + } + + /* normalize phase from degrees */ + phase /= 180; + + /* the value corresponding to i = -1 below */ + lastPhase = phase - frequency / sampleFrequency; + lastPhase -= floor (lastPhase); + + /* calculate samples */ + for (i = 0; i < numSamples; i++) + { + double p = phase + frequency * (double) i / sampleFrequency; + double currentPhase = p - floor (p); + double amplitude = func (lastPhase, currentPhase); + if (!_alutOutputStreamWriteInt16BE + (stream, (Int16BigEndian) (amplitude * 32767))) + { + _alutOutputStreamDestroy (stream); + return NULL; + } + lastPhase = currentPhase; + } + + return stream; +} + +ALvoid * +alutLoadMemoryWaveform (ALenum waveshape, ALfloat frequency, ALfloat phase, + ALfloat duration, ALenum *format, ALsizei *size, + ALfloat *freq) +{ + OutputStream *outputStream; + InputStream *inputStream; + ALvoid *data; + + if (!_alutSanityCheck ()) + { + return NULL; + } + + outputStream = generateWaveform (waveshape, frequency, phase, duration); + if (outputStream == NULL) + { + return NULL; + } + + /* We could do something more efficient here if the internal stream + structures were known, but this would break the abstraction. */ + inputStream = + _alutInputStreamConstructFromMemory (_alutOutputStreamGetData + (outputStream), + _alutOutputStreamGetLength + (outputStream)); + if (inputStream == NULL) + { + _alutOutputStreamDestroy (outputStream); + return NULL; + } + + data = _alutLoadMemoryFromInputStream (inputStream, format, size, freq); + _alutOutputStreamDestroy (outputStream); + return data; +} + +ALuint +alutCreateBufferWaveform (ALenum waveshape, ALfloat frequency, ALfloat phase, + ALfloat duration) +{ + OutputStream *outputStream; + InputStream *inputStream; + ALuint buffer; + + if (!_alutSanityCheck ()) + { + return AL_NONE; + } + + outputStream = generateWaveform (waveshape, frequency, phase, duration); + if (outputStream == NULL) + { + return AL_NONE; + } + + /* We could do something more efficient here if the internal stream + structures were known, but this would break the abstraction. */ + inputStream = + _alutInputStreamConstructFromMemory (_alutOutputStreamGetData + (outputStream), + _alutOutputStreamGetLength + (outputStream)); + if (inputStream == NULL) + { + _alutOutputStreamDestroy (outputStream); + return AL_NONE; + } + + buffer = _alutCreateBufferFromInputStream (inputStream); + _alutOutputStreamDestroy (outputStream); + return buffer; +} + +/* converted from helloworld.wav */ +static uint8_t helloWorldSample[] = { + 0x2e, 0x73, 0x6e, 0x64, /* ".snd" */ + 0x00, 0x00, 0x00, 0x18, /* byte offset to data part (24) */ + 0x00, 0x00, 0x1f, 0xf2, /* number of bytes in the data part (8178) */ + 0x00, 0x00, 0x00, 0x01, /* encoding of the data part (8-bit ISDN u-law) */ + 0x00, 0x00, 0x2b, 0x11, /* number of samples per second (11025) */ + 0x00, 0x00, 0x00, 0x01, /* number of interleaved channels (1) */ + + 0x7e, 0x7c, 0x7d, 0x7a, 0x79, 0xfc, 0xf8, 0x7e, 0x73, 0x6f, 0x7c, 0x7d, + 0x6f, 0x71, 0x78, 0x78, 0x77, 0x6f, 0x6b, 0x6e, 0x71, 0x6c, 0x6b, 0x75, + 0xff, 0x7b, 0x70, 0x6d, 0x6d, 0x6a, 0x6c, 0x74, 0x70, 0x73, 0x71, 0x63, + 0x68, 0xfb, 0xf4, 0x78, 0x6f, 0xfd, 0xef, 0x74, 0x62, 0x70, 0xf6, 0x6a, + 0x60, 0x6b, 0xf9, 0x7e, 0x6a, 0x7b, 0xea, 0x78, 0x62, 0x75, 0xe3, 0xe7, + 0x71, 0x66, 0x78, 0xf9, 0x6d, 0x6d, 0x77, 0x74, 0x6f, 0x68, 0x6a, 0xfe, + 0xf8, 0x7e, 0x6f, 0x6b, 0x72, 0xfe, 0xea, 0xe7, 0x72, 0x60, 0x6a, 0xed, + 0xe8, 0x6f, 0x62, 0x62, 0x6a, 0xf3, 0xef, 0x7e, 0xfd, 0x70, 0x64, 0x6e, + 0xed, 0xe6, 0xec, 0x6b, 0x5e, 0x7b, 0xe0, 0xe7, 0x7e, 0x62, 0x5c, 0x72, + 0xee, 0xf5, 0x74, 0x65, 0x69, 0x6d, 0xfd, 0xe6, 0xef, 0x6c, 0x6a, 0x7e, + 0xf6, 0x7a, 0x67, 0x64, 0x7b, 0x7c, 0x6b, 0xf0, 0xde, 0xfe, 0x5c, 0x5f, + 0x7c, 0xe5, 0xe4, 0xf6, 0x6e, 0x69, 0x7e, 0xe2, 0xe0, 0x77, 0x5d, 0x6a, + 0xf3, 0x6e, 0x6a, 0x79, 0xfa, 0xed, 0xeb, 0xeb, 0xec, 0x7e, 0x6f, 0x78, + 0x69, 0x64, 0x7d, 0xff, 0x74, 0x67, 0x6c, 0xe5, 0xee, 0x77, 0xf2, 0xeb, + 0xf2, 0x68, 0x67, 0x73, 0x6f, 0x74, 0xf2, 0xeb, 0x78, 0x66, 0x66, 0x71, + 0xe7, 0xe2, 0x6d, 0x65, 0xf1, 0x7a, 0x5f, 0x64, 0x73, 0x79, 0x75, 0xeb, + 0xe8, 0x6c, 0x6e, 0xee, 0xe5, 0xee, 0x66, 0x6c, 0xf5, 0x6b, 0x6f, 0xe5, + 0xec, 0x7b, 0x7d, 0x79, 0x76, 0x68, 0x67, 0xf6, 0xef, 0x6e, 0x73, 0xfd, + 0x7c, 0xf6, 0x75, 0x68, 0x72, 0x6a, 0x5e, 0x68, 0x77, 0x77, 0x68, 0x5e, + 0x6e, 0xea, 0xfb, 0x6a, 0xf5, 0xf1, 0x70, 0x6a, 0x6b, 0xde, 0xdf, 0x66, + 0x6e, 0x7d, 0x64, 0x5f, 0xf5, 0xe6, 0x7a, 0x7a, 0xee, 0xeb, 0x74, 0x60, + 0x76, 0xde, 0xf2, 0x58, 0x66, 0xdb, 0xdd, 0x6d, 0x5b, 0xfa, 0xe3, 0x68, + 0x6e, 0xe1, 0xe1, 0x73, 0x55, 0x5a, 0xe5, 0xda, 0xee, 0x7e, 0xef, 0x7c, + 0x6b, 0x7a, 0xe9, 0xe7, 0x72, 0x5e, 0x79, 0xe5, 0xfa, 0xff, 0x78, 0x64, + 0x6b, 0x7a, 0xf6, 0xf7, 0x78, 0xef, 0xe8, 0xf8, 0x7a, 0xef, 0xde, 0xe7, + 0x58, 0x58, 0xde, 0xdf, 0x6c, 0x74, 0xfa, 0xef, 0xed, 0xfd, 0xf8, 0xf4, + 0x66, 0x5f, 0xe7, 0xe0, 0x6e, 0x7c, 0xee, 0x71, 0x67, 0x69, 0xfb, 0xe7, + 0xed, 0x72, 0x6c, 0x6f, 0x67, 0x6b, 0xe8, 0xe2, 0x70, 0x6b, 0xf0, 0x64, + 0x58, 0xee, 0xe3, 0x66, 0x74, 0xe7, 0xed, 0x6d, 0x58, 0x56, 0x62, 0x6e, + 0x6d, 0xe8, 0xd8, 0xe2, 0x6f, 0x5e, 0x63, 0xfd, 0xfa, 0x6f, 0x64, 0x59, + 0x5b, 0x6e, 0x71, 0x69, 0x6c, 0x6c, 0x74, 0xe3, 0xdd, 0xf5, 0x69, 0x71, + 0x7e, 0x62, 0x65, 0xe6, 0xda, 0xee, 0x64, 0xed, 0xcd, 0xcd, 0xd8, 0xd6, + 0xcd, 0xd2, 0xea, 0xe0, 0xcd, 0xcf, 0xe9, 0x74, 0xdd, 0xd0, 0xd4, 0xdc, + 0xef, 0xe2, 0xdd, 0x69, 0x66, 0x76, 0x6c, 0x6d, 0x5c, 0x5a, 0x67, 0x6b, + 0x5c, 0x4c, 0x48, 0x4d, 0x5d, 0x5a, 0x4c, 0x51, 0x4f, 0x4f, 0x58, 0x4d, + 0x4e, 0x4d, 0x40, 0x40, 0x49, 0x4d, 0x4f, 0x4d, 0x3e, 0x38, 0x4c, 0xbe, + 0xb1, 0xb9, 0xc9, 0xcb, 0xcd, 0xf2, 0xe8, 0xd1, 0xd4, 0xeb, 0x4d, 0x54, + 0xca, 0xc2, 0xbf, 0xb7, 0xb2, 0xb7, 0xc6, 0xc4, 0xb8, 0xbe, 0xde, 0x77, + 0xd0, 0xcd, 0xe1, 0xdf, 0xcf, 0xc7, 0xda, 0x54, 0x59, 0x5d, 0x4f, 0x49, + 0x49, 0x51, 0x4d, 0x45, 0x46, 0x4a, 0x46, 0x3b, 0x38, 0x38, 0x38, 0x35, + 0x32, 0x33, 0x38, 0xe7, 0xb0, 0xb0, 0xbc, 0xce, 0xd8, 0x74, 0x47, 0x44, + 0x4b, 0x50, 0x43, 0x3e, 0x57, 0xca, 0xbb, 0xbc, 0xc0, 0xc1, 0xca, 0xde, + 0xee, 0xe0, 0xd3, 0x6c, 0x4d, 0xcf, 0xb7, 0xb9, 0xc7, 0xd1, 0xc5, 0xc7, + 0xe2, 0xf7, 0xd1, 0xcc, 0xfe, 0x5d, 0xe7, 0xce, 0xcd, 0xe1, 0x74, 0x67, + 0x4d, 0x3e, 0x3b, 0x3d, 0x3b, 0x39, 0x34, 0x33, 0x3c, 0x4b, 0x52, 0x4f, + 0xce, 0xaf, 0xae, 0xc3, 0x5c, 0x51, 0x51, 0x3d, 0x36, 0x3c, 0x4b, 0x4d, + 0x47, 0x5c, 0xc7, 0xb9, 0xbb, 0xbe, 0xbe, 0xc6, 0xe7, 0x57, 0x5a, 0x6b, + 0x60, 0x51, 0x54, 0xd0, 0xb7, 0xb4, 0xbc, 0xc0, 0xc5, 0xdc, 0x6b, 0xee, + 0xde, 0xe5, 0x63, 0x5c, 0x7d, 0xe1, 0xd1, 0xcf, 0xe8, 0x51, 0x3d, 0x32, + 0x2d, 0x2c, 0x30, 0x3e, 0x4d, 0x52, 0x62, 0xbe, 0xac, 0xad, 0xbc, 0xdc, + 0x58, 0x43, 0x38, 0x36, 0x3e, 0x48, 0x47, 0x46, 0x6a, 0xbf, 0xb4, 0xb4, + 0xb9, 0xc0, 0xcf, 0x71, 0x57, 0x5b, 0x5d, 0x50, 0x47, 0x4b, 0x63, 0xdd, + 0xc4, 0xb3, 0xad, 0xb2, 0xc9, 0xfc, 0xf9, 0xf5, 0x58, 0x4d, 0x53, 0x5a, + 0x56, 0x53, 0xf1, 0xcd, 0xda, 0x52, 0x3d, 0x38, 0x2f, 0x27, 0x2b, 0x43, + 0xd5, 0xbd, 0xb0, 0xae, 0xb6, 0xc4, 0xe9, 0x6f, 0x71, 0x4a, 0x38, 0x34, + 0x36, 0x3a, 0x4a, 0xde, 0xbe, 0xb6, 0xb9, 0xbf, 0xc3, 0xc9, 0xcf, 0xe3, + 0x5d, 0x4e, 0x44, 0x3f, 0x45, 0x52, 0xf6, 0xd2, 0xc3, 0xb6, 0xb2, 0xb5, + 0xb8, 0xbd, 0xd2, 0x4e, 0x41, 0x43, 0x47, 0x4a, 0x4a, 0x53, 0x5e, 0x51, + 0x48, 0x41, 0x3e, 0x2e, 0x28, 0x37, 0xc1, 0xac, 0xac, 0xb4, 0xbf, 0xd5, + 0x51, 0x46, 0x6e, 0xde, 0x4d, 0x38, 0x2f, 0x33, 0x4a, 0xce, 0xba, 0xb1, + 0xb3, 0xc0, 0xde, 0x71, 0xdc, 0xce, 0xde, 0x59, 0x47, 0x3e, 0x3e, 0x49, + 0x7a, 0xc8, 0xc0, 0xc3, 0xbc, 0xb7, 0xb8, 0xbb, 0xbf, 0xd3, 0x52, 0x3f, + 0x3d, 0x44, 0x4e, 0x4f, 0x4f, 0x4b, 0x45, 0x3f, 0x3c, 0x38, 0x2e, 0x2f, + 0xe1, 0xab, 0xaa, 0xb6, 0xc1, 0xca, 0xf7, 0x47, 0x44, 0xfa, 0xdd, 0x3e, + 0x2d, 0x2f, 0x41, 0xec, 0xc6, 0xb8, 0xaf, 0xb4, 0xcd, 0x66, 0xe8, 0xcb, + 0xcc, 0x6e, 0x4a, 0x44, 0x3e, 0x3c, 0x47, 0xdc, 0xc0, 0xc2, 0xc9, 0xc0, + 0xb7, 0xb4, 0xbd, 0xc9, 0xca, 0xde, 0x48, 0x3b, 0x3f, 0x4e, 0x51, 0x49, + 0x42, 0x42, 0x43, 0x39, 0x32, 0x2f, 0x31, 0xde, 0xaa, 0xaa, 0xb6, 0xbb, + 0xc4, 0x6c, 0x4b, 0x49, 0x6c, 0xd5, 0x43, 0x2e, 0x31, 0x3c, 0x51, 0xce, + 0xbc, 0xb1, 0xb1, 0xc2, 0xee, 0xd8, 0xc8, 0xc7, 0xd6, 0x5e, 0x55, 0x42, + 0x37, 0x3c, 0x50, 0xd9, 0xcb, 0xc4, 0xb9, 0xb5, 0xb6, 0xbd, 0xc5, 0xbe, + 0xc6, 0x5e, 0x42, 0x3e, 0x3f, 0x3d, 0x3a, 0x3a, 0x3d, 0x3b, 0x33, 0x2d, + 0x2a, 0x36, 0xb7, 0xa5, 0xab, 0xb1, 0xb4, 0xc9, 0x52, 0x44, 0x4b, 0xcf, + 0xd7, 0x37, 0x2d, 0x2f, 0x34, 0x3f, 0xeb, 0xbb, 0xad, 0xaf, 0xc5, 0xd4, + 0xc7, 0xc2, 0xc1, 0xc5, 0xd2, 0xfb, 0x43, 0x31, 0x33, 0x3f, 0x53, 0xcf, + 0xba, 0xb6, 0xb5, 0xba, 0xbe, 0xbb, 0xba, 0xc4, 0xdc, 0x5c, 0x43, 0x3a, + 0x35, 0x35, 0x37, 0x35, 0x30, 0x2c, 0x27, 0x2c, 0xcf, 0xaa, 0xab, 0xac, + 0xab, 0xb3, 0xc9, 0x5c, 0x58, 0xc6, 0xc3, 0x47, 0x33, 0x2f, 0x2d, 0x2f, + 0x38, 0x58, 0xb9, 0xb2, 0xbf, 0xc6, 0xbf, 0xbe, 0xbb, 0xba, 0xba, 0xb9, + 0xcc, 0x40, 0x35, 0x38, 0x43, 0x5e, 0xde, 0xc5, 0xb9, 0xbd, 0xd9, 0xeb, + 0xc9, 0xbe, 0xc6, 0xe4, 0x5b, 0x48, 0x39, 0x2f, 0x2c, 0x2b, 0x29, 0x28, + 0x32, 0xd3, 0xb7, 0xbc, 0xba, 0xb2, 0xb3, 0xba, 0xc4, 0xbf, 0xb5, 0xbe, + 0x4c, 0x38, 0x37, 0x35, 0x32, 0x35, 0x46, 0xd6, 0xd2, 0x66, 0xe6, 0xc0, + 0xb9, 0xb8, 0xb6, 0xb2, 0xb2, 0xbf, 0x65, 0x64, 0xdc, 0xea, 0x7c, 0xe2, + 0xdc, 0xfc, 0x4f, 0x49, 0x5a, 0xe5, 0xf0, 0x5e, 0x55, 0x48, 0x3a, 0x2e, + 0x2a, 0x27, 0x2b, 0x51, 0xb8, 0xb9, 0xbe, 0xba, 0xbd, 0xcf, 0xda, 0xcc, + 0xb8, 0xb0, 0xc3, 0x4e, 0x40, 0x39, 0x33, 0x37, 0x45, 0xd9, 0xc1, 0xd9, + 0x58, 0xf9, 0xd8, 0xcf, 0xbf, 0xb6, 0xb0, 0xb3, 0xc9, 0x57, 0x69, 0xd7, + 0xd4, 0xcb, 0xc2, 0xc7, 0xf5, 0x48, 0x42, 0x4d, 0x6c, 0x6f, 0x69, 0x62, + 0x4b, 0x3a, 0x2f, 0x2a, 0x28, 0x29, 0x30, 0xed, 0xb5, 0xb7, 0xbd, 0xbb, + 0xbe, 0xcb, 0xd0, 0xc8, 0xb8, 0xb4, 0xc8, 0x4a, 0x3d, 0x39, 0x35, 0x38, + 0x46, 0xd9, 0xc3, 0xd6, 0x5f, 0xf2, 0xcf, 0xc9, 0xbf, 0xb7, 0xb1, 0xb4, + 0xc4, 0xe1, 0xd0, 0xca, 0xcf, 0xd0, 0xcd, 0xd0, 0xfd, 0x49, 0x41, 0x4a, + 0x55, 0x59, 0x56, 0x53, 0x4a, 0x3a, 0x2e, 0x28, 0x26, 0x2a, 0x38, 0xda, + 0xb6, 0xb5, 0xb9, 0xb8, 0xc1, 0xde, 0xd2, 0xc0, 0xba, 0xb8, 0xc7, 0x50, + 0x41, 0x3b, 0x35, 0x3a, 0x4f, 0xe0, 0xca, 0xcd, 0xec, 0xdd, 0xd1, 0xd5, + 0xc3, 0xb7, 0xb5, 0xb8, 0xbf, 0xc8, 0xc9, 0xcb, 0xd9, 0xd9, 0xce, 0xd5, + 0x69, 0x4e, 0x4c, 0x4c, 0x4f, 0x51, 0x4e, 0x4f, 0x4a, 0x3c, 0x30, 0x2a, + 0x27, 0x2a, 0x2d, 0x38, 0xc6, 0xaf, 0xba, 0xbf, 0xbb, 0xc4, 0xd0, 0xcd, + 0xc9, 0xb9, 0xb3, 0xce, 0x48, 0x45, 0x3e, 0x3a, 0x3e, 0x4b, 0xde, 0xc2, + 0xd4, 0x6e, 0xd6, 0xcc, 0xce, 0xc4, 0xbb, 0xb6, 0xb5, 0xbc, 0xc7, 0xc3, + 0xc4, 0xd3, 0xdc, 0xd5, 0xdd, 0x64, 0x4e, 0x4a, 0x4f, 0x61, 0x5d, 0x55, + 0x5a, 0x4f, 0x3c, 0x31, 0x2b, 0x28, 0x2b, 0x2c, 0x2c, 0x44, 0xb7, 0xb5, + 0xc6, 0xbb, 0xb6, 0xc3, 0xcd, 0xd2, 0xc9, 0xb5, 0xb9, 0x73, 0x58, 0x64, + 0x40, 0x39, 0x3e, 0x4b, 0xda, 0xc7, 0xe2, 0xdd, 0xc3, 0xcc, 0xd6, 0xc5, + 0xbf, 0xba, 0xb6, 0xbe, 0xc2, 0xbd, 0xc5, 0xde, 0xdf, 0xdd, 0xf5, 0x61, + 0x55, 0x51, 0x64, 0xf7, 0x63, 0x66, 0xfd, 0x57, 0x43, 0x38, 0x2e, 0x2b, + 0x2b, 0x2a, 0x29, 0x2b, 0x3f, 0xbf, 0xba, 0xc6, 0xba, 0xb1, 0xbc, 0xce, + 0xd0, 0xc5, 0xb8, 0xba, 0xd8, 0xee, 0xea, 0x46, 0x39, 0x3b, 0x42, 0x66, + 0xd3, 0xe7, 0xda, 0xc3, 0xca, 0xd7, 0xc8, 0xc0, 0xbd, 0xb9, 0xbc, 0xbd, + 0xb9, 0xc1, 0xdd, 0xdf, 0xdf, 0x65, 0x5b, 0x61, 0x64, 0x77, 0xf4, 0x6f, + 0xf1, 0xd9, 0xe7, 0x5b, 0x49, 0x3b, 0x30, 0x2c, 0x2a, 0x29, 0x2a, 0x2a, + 0x2c, 0x4c, 0xbd, 0xc2, 0xc9, 0xb4, 0xb0, 0xbb, 0xc3, 0xc6, 0xbe, 0xb5, + 0xbe, 0xfe, 0xe5, 0xe8, 0x43, 0x3a, 0x3b, 0x3f, 0x56, 0xfc, 0x5d, 0xd3, + 0xbb, 0xc3, 0xcc, 0xc0, 0xc0, 0xc0, 0xbc, 0xc4, 0xc2, 0xb8, 0xbf, 0xd8, + 0xd5, 0xe1, 0x5f, 0x6d, 0x6d, 0x66, 0xda, 0xd2, 0xe8, 0xdc, 0xd1, 0xdc, + 0xe8, 0x6a, 0x47, 0x3c, 0x37, 0x2e, 0x2a, 0x2a, 0x29, 0x29, 0x29, 0x2d, + 0x4d, 0xbf, 0xc5, 0xbf, 0xae, 0xae, 0xbb, 0xc2, 0xc6, 0xc4, 0xbd, 0xcd, + 0x63, 0xdf, 0xf4, 0x3f, 0x3b, 0x3e, 0x40, 0x5a, 0xf1, 0x78, 0xc6, 0xb9, + 0xc4, 0xc7, 0xbe, 0xc4, 0xc3, 0xbe, 0xc9, 0xc8, 0xbb, 0xc2, 0xd3, 0xc8, + 0xcf, 0x7d, 0xe5, 0x7a, 0x5f, 0xd6, 0xd1, 0xf0, 0xd2, 0xc9, 0xd8, 0xda, + 0xd9, 0x68, 0x4f, 0x42, 0x37, 0x33, 0x30, 0x2c, 0x29, 0x2a, 0x29, 0x26, + 0x2b, 0x47, 0xc8, 0xcb, 0xbf, 0xae, 0xae, 0xba, 0xbf, 0xcc, 0xc7, 0xbb, + 0xce, 0x5e, 0xce, 0xd5, 0x46, 0x40, 0x41, 0x3f, 0x5f, 0xf8, 0x5a, 0xc6, + 0xb6, 0xc3, 0xc4, 0xbb, 0xc7, 0xc5, 0xbe, 0xd6, 0xcf, 0xbb, 0xc7, 0xd4, + 0xc1, 0xcd, 0xf7, 0xd5, 0xed, 0x5e, 0xd5, 0xd2, 0xec, 0xcd, 0xca, 0xdc, + 0xd0, 0xce, 0xe9, 0xe3, 0xe0, 0x54, 0x41, 0x3a, 0x32, 0x2e, 0x2b, 0x27, + 0x26, 0x28, 0x26, 0x23, 0x2a, 0xff, 0xb2, 0xbe, 0xb9, 0xa5, 0xa8, 0xbb, + 0xc6, 0xe0, 0xeb, 0xc7, 0x55, 0x3b, 0xea, 0xd5, 0x3e, 0x3c, 0x47, 0x48, + 0xdc, 0xc7, 0xce, 0xb1, 0xa8, 0xb1, 0xb8, 0xb2, 0xbd, 0xc9, 0xcf, 0x53, + 0x63, 0xd8, 0x48, 0x41, 0xec, 0xde, 0xd8, 0xc2, 0xca, 0xc2, 0xb4, 0xc0, + 0xd8, 0xbf, 0xc6, 0xea, 0xdd, 0x70, 0x60, 0xda, 0x6a, 0x4e, 0xfb, 0x75, + 0x47, 0x3e, 0x37, 0x30, 0x2f, 0x2c, 0x29, 0x2a, 0x2b, 0x28, 0x27, 0x27, + 0x25, 0x3c, 0xac, 0xa8, 0xb0, 0xa0, 0x9d, 0xb3, 0xe2, 0x57, 0x35, 0x40, + 0x54, 0x2f, 0x3a, 0xc2, 0x52, 0x36, 0x76, 0xd3, 0xcb, 0xae, 0xae, 0xad, + 0xa0, 0xa7, 0xc1, 0xbd, 0xc7, 0x42, 0x43, 0x3e, 0x35, 0x4d, 0x4e, 0x34, + 0x40, 0xf9, 0x5a, 0xcd, 0xb7, 0xb1, 0xa8, 0xa9, 0xbc, 0xbd, 0xbe, 0x4d, + 0x44, 0x4d, 0x44, 0x68, 0xe4, 0x4f, 0xe7, 0xca, 0xec, 0xf0, 0xe6, 0x64, + 0x5b, 0x45, 0x38, 0x3a, 0x3a, 0x31, 0x30, 0x32, 0x2e, 0x2d, 0x2a, 0x23, + 0x25, 0x24, 0x1f, 0x3e, 0xa1, 0xa3, 0xab, 0x9b, 0x9c, 0xba, 0xe5, 0x3b, + 0x2b, 0x4e, 0x50, 0x2a, 0x4a, 0xb8, 0x4c, 0x43, 0xcf, 0xe3, 0xb8, 0xa7, + 0xb0, 0xab, 0x9e, 0xad, 0xd5, 0xcd, 0x47, 0x35, 0x3d, 0x31, 0x32, 0x66, + 0x4f, 0x3b, 0x5e, 0xdc, 0xe8, 0xc1, 0xbc, 0xba, 0xad, 0xad, 0xbd, 0xc1, + 0xc7, 0x58, 0x4b, 0x4c, 0x49, 0xf9, 0xcf, 0xdd, 0xcf, 0xc7, 0xce, 0xdc, + 0xe7, 0xdd, 0xe2, 0x6e, 0x6a, 0x5a, 0x50, 0x52, 0x42, 0x3d, 0x47, 0x3e, + 0x37, 0x3a, 0x34, 0x2d, 0x2c, 0x28, 0x26, 0x27, 0x25, 0x26, 0x2b, 0x27, + 0x2e, 0xaa, 0x9c, 0xa8, 0x9f, 0x99, 0xa8, 0xca, 0x45, 0x29, 0x35, 0x54, + 0x2b, 0x32, 0xbc, 0xc6, 0xfb, 0xbf, 0xc1, 0xaf, 0xa3, 0xac, 0xaf, 0xa1, + 0xaa, 0xd6, 0x66, 0x3d, 0x33, 0x3b, 0x30, 0x2f, 0x62, 0xe1, 0x49, 0xef, + 0xcb, 0xcc, 0xbc, 0xbf, 0xcb, 0xb8, 0xb8, 0xe0, 0x6c, 0x6f, 0x4f, 0x51, + 0x4e, 0x4f, 0xd0, 0xbf, 0xc7, 0xc4, 0xc0, 0xc5, 0xcf, 0x6a, 0x59, 0x6f, + 0x60, 0x55, 0x5c, 0x7e, 0xdc, 0xe7, 0x65, 0xee, 0xe0, 0x60, 0x4f, 0x4b, + 0x43, 0x3e, 0x38, 0x35, 0x39, 0x3a, 0x39, 0x3b, 0x3d, 0x39, 0x37, 0x34, + 0x2e, 0x2c, 0x2c, 0x28, 0x29, 0x28, 0x29, 0xca, 0x9e, 0xa2, 0xa4, 0x99, + 0xa0, 0xc0, 0x68, 0x2d, 0x2b, 0x58, 0x39, 0x2e, 0xc7, 0xbc, 0x77, 0xc0, + 0xbf, 0xbd, 0xa7, 0xaa, 0xb5, 0xa6, 0xaa, 0xcc, 0xe8, 0x42, 0x33, 0x41, + 0x3a, 0x34, 0xf0, 0xcc, 0x69, 0xce, 0xcb, 0xce, 0xbb, 0xbf, 0xcd, 0xbb, + 0xbd, 0xec, 0x5e, 0x4a, 0x40, 0x48, 0x45, 0x46, 0xe5, 0xc8, 0xc6, 0xc2, + 0xc4, 0xc2, 0xc4, 0xdf, 0x77, 0xe0, 0x7a, 0x5c, 0x5a, 0x5d, 0x7d, 0x75, + 0x5e, 0xfa, 0xda, 0xde, 0xf7, 0x6f, 0x6a, 0x56, 0x46, 0x3f, 0x40, 0x41, + 0x41, 0x43, 0x49, 0x53, 0x52, 0x4b, 0x49, 0x48, 0x43, 0x3c, 0x37, 0x38, + 0x39, 0x36, 0x35, 0x32, 0x30, 0x31, 0x2f, 0x2d, 0x2e, 0x30, 0x33, 0xc3, + 0x9e, 0x9f, 0xa4, 0x9c, 0xa2, 0xc8, 0x4d, 0x30, 0x2b, 0x49, 0x46, 0x37, + 0xc7, 0xb7, 0xd1, 0xbe, 0xbe, 0xc0, 0xab, 0xac, 0xb6, 0xaa, 0xad, 0xd4, + 0xea, 0x41, 0x32, 0x41, 0x3d, 0x38, 0xe2, 0xcc, 0xee, 0xc9, 0xcb, 0xd1, + 0xbe, 0xc6, 0xcf, 0xbe, 0xc5, 0xee, 0x5f, 0x48, 0x41, 0x43, 0x3f, 0x46, + 0x66, 0xdb, 0xcc, 0xcd, 0xd0, 0xcb, 0xd3, 0x7c, 0xec, 0xd7, 0xd5, 0xdc, + 0xee, 0x73, 0x65, 0x59, 0x51, 0x53, 0x68, 0xe1, 0xdd, 0xdc, 0xd9, 0xec, + 0x60, 0x59, 0x51, 0x4f, 0x53, 0x54, 0x5c, 0x61, 0x58, 0x57, 0x59, 0x51, + 0x4d, 0x49, 0x44, 0x44, 0x42, 0x3e, 0x3e, 0x3e, 0x3e, 0x3e, 0x3c, 0x3b, + 0x3b, 0x37, 0x34, 0x32, 0x2f, 0x2d, 0x2f, 0x33, 0x36, 0xbf, 0x9f, 0xa1, + 0xa7, 0x9f, 0xa6, 0xcb, 0x55, 0x34, 0x30, 0x62, 0x4c, 0x3d, 0xc6, 0xbd, + 0xd6, 0xc1, 0xcb, 0xc0, 0xaa, 0xaf, 0xb7, 0xaa, 0xb3, 0xd7, 0xf5, 0x3b, + 0x36, 0x49, 0x3a, 0x3b, 0xde, 0xdb, 0xe5, 0xcc, 0xd5, 0xca, 0xbd, 0xc9, + 0xcb, 0xc3, 0xd0, 0x6f, 0x4e, 0x42, 0x43, 0x44, 0x45, 0x4e, 0x6f, 0xd7, + 0xd0, 0xdb, 0xdf, 0xdd, 0xe3, 0xfb, 0x6c, 0xf8, 0xeb, 0x65, 0x53, 0x4f, + 0x55, 0x5a, 0x57, 0xf2, 0xcb, 0xcc, 0xd3, 0xd6, 0xea, 0x6f, 0x5e, 0x4d, + 0x51, 0x60, 0x59, 0x63, 0xf1, 0xf4, 0xe3, 0xdf, 0xed, 0xe5, 0xee, 0x61, + 0x5e, 0x58, 0x4f, 0x4f, 0x4a, 0x45, 0x45, 0x45, 0x46, 0x47, 0x48, 0x4a, + 0x45, 0x3f, 0x3d, 0x3a, 0x37, 0x35, 0x31, 0x31, 0x33, 0x31, 0x33, 0x44, + 0xb5, 0xa2, 0xa6, 0xa9, 0xa2, 0xad, 0xeb, 0x41, 0x34, 0x3a, 0x59, 0x44, + 0x45, 0xc7, 0xc7, 0xe3, 0xce, 0xc7, 0xb6, 0xac, 0xb1, 0xb0, 0xad, 0xbb, + 0xe4, 0x4b, 0x3a, 0x3e, 0x43, 0x3b, 0x49, 0xe5, 0xee, 0x7b, 0xea, 0xd9, + 0xc4, 0xbe, 0xc1, 0xbe, 0xbd, 0xcb, 0x62, 0x49, 0x43, 0x40, 0x40, 0x46, + 0x50, 0x76, 0xe0, 0xea, 0xf1, 0xdf, 0xd9, 0xdc, 0xde, 0xd9, 0xda, 0xfe, + 0x54, 0x49, 0x47, 0x48, 0x47, 0x46, 0x55, 0xf8, 0xeb, 0xe7, 0xd7, 0xca, + 0xcb, 0xde, 0xed, 0xdf, 0xe1, 0x74, 0x5c, 0x60, 0x7a, 0x6f, 0x61, 0x7c, + 0xda, 0xd2, 0xd6, 0xd9, 0xd5, 0xd9, 0xf2, 0x61, 0x5a, 0x5d, 0x61, 0x59, + 0x58, 0x60, 0x5c, 0x4f, 0x4b, 0x47, 0x42, 0x3e, 0x3c, 0x3b, 0x3b, 0x3a, + 0x39, 0x3a, 0x3a, 0x3a, 0x3a, 0x37, 0x36, 0x3a, 0x6f, 0xae, 0xa8, 0xae, + 0xaa, 0xaa, 0xc9, 0x4a, 0x3f, 0x38, 0x4e, 0xf5, 0x48, 0x77, 0xc6, 0xfd, + 0x63, 0xd5, 0xc4, 0xb3, 0xae, 0xb2, 0xaf, 0xb3, 0xcb, 0x56, 0x45, 0x44, + 0x48, 0x49, 0x4d, 0x60, 0x73, 0x5d, 0x52, 0x69, 0xd0, 0xc5, 0xbe, 0xbc, + 0xbd, 0xc3, 0xea, 0x4c, 0x45, 0x43, 0x44, 0x4a, 0x52, 0x68, 0x7d, 0x65, + 0x5f, 0x67, 0xfb, 0xde, 0xda, 0xd6, 0xd1, 0xe2, 0x5b, 0x4c, 0x47, 0x46, + 0x49, 0x49, 0x51, 0x6d, 0x72, 0x60, 0x7e, 0xde, 0xe0, 0xd6, 0xc9, 0xc7, + 0xca, 0xd6, 0x78, 0x60, 0x5a, 0x4f, 0x54, 0x76, 0xde, 0xd5, 0xd4, 0xdb, + 0xd7, 0xd3, 0xdc, 0xdd, 0xd7, 0xdc, 0xed, 0x6d, 0x59, 0x51, 0x51, 0x50, + 0x54, 0x5f, 0x61, 0x59, 0x52, 0x4c, 0x49, 0x47, 0x42, 0x3f, 0x42, 0x40, + 0x3c, 0x3b, 0x3e, 0x40, 0x3c, 0x38, 0x38, 0x38, 0x3a, 0x48, 0xbf, 0xaa, + 0xab, 0xaf, 0xab, 0xb5, 0xf2, 0x55, 0x46, 0x4c, 0xd9, 0x5f, 0x47, 0x74, + 0x5f, 0x45, 0x54, 0xd7, 0xbb, 0xaf, 0xb0, 0xb3, 0xb3, 0xbe, 0xea, 0x4f, + 0x54, 0x65, 0x5d, 0x55, 0x4f, 0x4d, 0x4a, 0x41, 0x44, 0xfe, 0xca, 0xc1, + 0xbd, 0xbd, 0xc1, 0xd0, 0x5a, 0x50, 0x59, 0x56, 0x51, 0x51, 0x4e, 0x4a, + 0x46, 0x43, 0x49, 0x68, 0xd5, 0xce, 0xc9, 0xc6, 0xce, 0xe9, 0x5f, 0x57, + 0x5c, 0x5d, 0x53, 0x51, 0x52, 0x4d, 0x47, 0x48, 0x54, 0x78, 0xd9, 0xcc, + 0xc7, 0xc3, 0xc2, 0xc8, 0xd6, 0xe2, 0xed, 0x69, 0x5a, 0x5c, 0x5f, 0x5d, + 0x5b, 0x5c, 0x67, 0xeb, 0xdf, 0xda, 0xcf, 0xcb, 0xcc, 0xd9, 0xef, 0x72, + 0x60, 0x55, 0x4f, 0x50, 0x53, 0x4f, 0x4c, 0x4b, 0x4d, 0x4f, 0x4f, 0x51, + 0x59, 0x5a, 0x54, 0x51, 0x4d, 0x4a, 0x47, 0x44, 0x42, 0x41, 0x41, 0x40, + 0x3e, 0x3c, 0x3a, 0x39, 0x4d, 0xb9, 0xad, 0xb3, 0xae, 0xab, 0xbc, 0xde, + 0x72, 0x55, 0xe0, 0xd5, 0x4e, 0x4e, 0x63, 0x45, 0x3d, 0x4c, 0xdc, 0xbe, + 0xb8, 0xb8, 0xb8, 0xb8, 0xc3, 0xee, 0xef, 0xd4, 0xde, 0x7d, 0x5d, 0x4c, + 0x46, 0x3c, 0x39, 0x46, 0x7a, 0xd3, 0xc8, 0xc3, 0xc2, 0xc7, 0xdc, 0xf5, + 0xdc, 0xd3, 0xda, 0xf7, 0x67, 0x55, 0x46, 0x3f, 0x40, 0x4c, 0x67, 0xef, + 0xdf, 0xd5, 0xd5, 0xe3, 0xfd, 0xeb, 0xd9, 0xd6, 0xdf, 0x7c, 0x5f, 0x53, + 0x47, 0x41, 0x47, 0x55, 0x61, 0x6b, 0xf6, 0xdd, 0xd4, 0xd0, 0xce, 0xcc, + 0xca, 0xcd, 0xda, 0xf3, 0x6b, 0x61, 0x5a, 0x56, 0x5e, 0x6c, 0x70, 0x77, + 0xf0, 0xe3, 0xdc, 0xd8, 0xd8, 0xda, 0xde, 0xf2, 0x67, 0x5a, 0x52, 0x4d, + 0x4b, 0x4b, 0x4c, 0x4d, 0x4e, 0x4e, 0x4f, 0x52, 0x54, 0x54, 0x56, 0x58, + 0x54, 0x4e, 0x4c, 0x4a, 0x45, 0x42, 0x45, 0x44, 0x42, 0x42, 0x40, 0x40, + 0x3f, 0x41, 0xcd, 0xb0, 0xb9, 0xba, 0xaf, 0xba, 0xcd, 0xd3, 0xfe, 0xd0, + 0xc2, 0xed, 0x54, 0x5f, 0x4d, 0x3f, 0x41, 0x61, 0xc9, 0xbf, 0xbe, 0xbf, + 0xbe, 0xbe, 0xcf, 0xd6, 0xc3, 0xc1, 0xcb, 0xe0, 0x5b, 0x4e, 0x43, 0x3c, + 0x3f, 0x53, 0xeb, 0xe1, 0xe2, 0xd7, 0xd6, 0xdd, 0xdd, 0xd3, 0xc6, 0xc4, + 0xcf, 0xe9, 0x61, 0x4e, 0x44, 0x42, 0x47, 0x4f, 0x58, 0x56, 0x4f, 0x55, + 0x5c, 0x5d, 0x7b, 0xd5, 0xcb, 0xcb, 0xd4, 0xed, 0x6b, 0x5f, 0x5a, 0x5e, + 0xe5, 0xd3, 0xdc, 0x7c, 0x66, 0x60, 0x5e, 0x62, 0xef, 0xd4, 0xd0, 0xdb, + 0xf1, 0x72, 0x71, 0x77, 0xf1, 0xdc, 0xd1, 0xd5, 0xed, 0x66, 0x5b, 0x5b, + 0x5c, 0x5a, 0x63, 0x6a, 0x57, 0x4d, 0x4c, 0x4c, 0x4d, 0x4f, 0x52, 0x58, + 0x58, 0x50, 0x4a, 0x4a, 0x4e, 0x4d, 0x4a, 0x4c, 0x4d, 0x4b, 0x44, 0x40, + 0x43, 0x46, 0x46, 0x46, 0x4a, 0x48, 0x47, 0xcf, 0xb6, 0xbb, 0xbb, 0xb0, + 0xb8, 0xc5, 0xc7, 0xd8, 0xcd, 0xc1, 0xd9, 0x5d, 0x6a, 0x5b, 0x46, 0x44, + 0x59, 0xe1, 0xce, 0xc8, 0xcc, 0xc8, 0xc0, 0xca, 0xce, 0xc0, 0xbe, 0xc4, + 0xce, 0xea, 0x5c, 0x4e, 0x47, 0x42, 0x4b, 0x61, 0x5a, 0x52, 0x5d, 0x61, + 0x65, 0xf1, 0xdd, 0xcd, 0xc5, 0xc9, 0xd8, 0xe7, 0xf6, 0x5e, 0x56, 0x58, + 0x58, 0x57, 0x51, 0x47, 0x45, 0x4a, 0x4c, 0x4e, 0x62, 0xea, 0xdd, 0xdf, + 0xef, 0xe2, 0xd4, 0xd8, 0xd9, 0xce, 0xcd, 0xd0, 0xd8, 0xed, 0x76, 0xfc, + 0x72, 0x63, 0x70, 0xf3, 0x6b, 0x61, 0x66, 0x64, 0x7b, 0xe1, 0xe0, 0xdc, + 0xd4, 0xdc, 0x7c, 0x68, 0x60, 0x5d, 0x5c, 0x59, 0x54, 0x51, 0x4d, 0x47, + 0x45, 0x48, 0x4a, 0x4e, 0x53, 0x55, 0x54, 0x53, 0x4f, 0x4d, 0x4e, 0x51, + 0x53, 0x53, 0x51, 0x4f, 0x4f, 0x4d, 0x4b, 0x4d, 0x50, 0x4f, 0x4d, 0x48, + 0x45, 0xe3, 0xbc, 0xc6, 0xc5, 0xb5, 0xba, 0xc4, 0xc4, 0xcc, 0xc6, 0xbc, + 0xc6, 0xe0, 0xdd, 0xd9, 0x58, 0x46, 0x58, 0xfc, 0xeb, 0xd7, 0xe5, 0xe6, + 0xcc, 0xd2, 0xe8, 0xd0, 0xc0, 0xc0, 0xca, 0xcc, 0xd4, 0xf3, 0x6c, 0x53, + 0x4d, 0x68, 0x6c, 0x4f, 0x4d, 0x50, 0x4f, 0x4e, 0x54, 0x66, 0xe6, 0xd4, + 0xda, 0xf8, 0xeb, 0xe6, 0x79, 0x6b, 0xf8, 0xe2, 0xee, 0x63, 0x55, 0x4e, + 0x4f, 0x4e, 0x4c, 0x5e, 0xec, 0xfb, 0xf8, 0xdf, 0xd6, 0xd4, 0xd3, 0xcf, + 0xcc, 0xcb, 0xcf, 0xe1, 0xe9, 0xeb, 0x6a, 0x5f, 0x6b, 0x70, 0x6b, 0x66, + 0x5e, 0x5b, 0x5f, 0x61, 0x5b, 0x65, 0xfb, 0x6e, 0x5f, 0x5d, 0x58, 0x55, + 0x54, 0x51, 0x50, 0x54, 0x54, 0x4d, 0x49, 0x4a, 0x49, 0x49, 0x4b, 0x4c, + 0x4d, 0x4e, 0x4b, 0x4b, 0x4e, 0x53, 0x5c, 0x62, 0x6d, 0xf9, 0xfa, 0x69, + 0x5f, 0x66, 0x6e, 0x6c, 0x72, 0xea, 0xcf, 0xc7, 0xcb, 0xcc, 0xc4, 0xc4, + 0xc9, 0xc9, 0xc9, 0xc7, 0xc5, 0xca, 0xd3, 0xd8, 0xd5, 0xe2, 0x78, 0xee, + 0xe6, 0xea, 0xeb, 0xf6, 0xfe, 0xee, 0xe7, 0xee, 0xed, 0xda, 0xd5, 0xdb, + 0xdf, 0xe0, 0xe4, 0xe8, 0xf8, 0x6f, 0x79, 0xf8, 0x6f, 0x5e, 0x5d, 0x5e, + 0x5a, 0x56, 0x57, 0x5b, 0x5f, 0x63, 0x61, 0x64, 0x75, 0x7d, 0x7c, 0xea, + 0xe4, 0xdf, 0xd5, 0xd2, 0xd5, 0xd4, 0xd4, 0xdc, 0xe1, 0xdf, 0xec, 0xf9, + 0xf5, 0x7a, 0x6c, 0x68, 0x63, 0x62, 0x68, 0x71, 0x7e, 0x7c, 0x77, 0x72, + 0x65, 0x5f, 0x61, 0x5e, 0x5c, 0x5e, 0x5e, 0x58, 0x55, 0x51, 0x4d, 0x4c, + 0x4c, 0x4b, 0x4a, 0x4b, 0x4c, 0x4a, 0x4a, 0x4b, 0x4b, 0x4a, 0x4b, 0x4e, + 0x51, 0x55, 0x5b, 0x61, 0x6d, 0xff, 0xf5, 0xf2, 0xec, 0xe2, 0xdf, 0xe5, + 0xe8, 0xe4, 0xe0, 0xe5, 0xe2, 0xd8, 0xd1, 0xcd, 0xcb, 0xca, 0xca, 0xc9, + 0xcb, 0xce, 0xcd, 0xcc, 0xce, 0xcf, 0xd1, 0xd5, 0xd9, 0xdd, 0xe9, 0xf6, + 0xf2, 0xf6, 0x7c, 0xfa, 0xf6, 0xf5, 0xef, 0xf3, 0xfa, 0xf5, 0xee, 0xee, + 0xf1, 0xee, 0xea, 0xea, 0xed, 0xef, 0xf6, 0xfe, 0x77, 0x73, 0x71, 0x6f, + 0x6e, 0x6c, 0x6d, 0x6f, 0x6b, 0x6e, 0xf7, 0xed, 0xe7, 0xdd, 0xd9, 0xd9, + 0xd8, 0xd6, 0xda, 0xde, 0xdf, 0xe6, 0xea, 0xed, 0xfd, 0x6f, 0x6d, 0x68, + 0x5f, 0x5d, 0x5b, 0x59, 0x58, 0x57, 0x56, 0x53, 0x51, 0x4f, 0x4d, 0x4d, + 0x4d, 0x4d, 0x4c, 0x4d, 0x4d, 0x4d, 0x4d, 0x4d, 0x4e, 0x4d, 0x4d, 0x4d, + 0x4d, 0x4f, 0x52, 0x51, 0x54, 0x5b, 0x5e, 0x5e, 0x62, 0x6d, 0xfc, 0xee, + 0xe8, 0xdf, 0xdd, 0xdb, 0xdb, 0xdd, 0xdc, 0xda, 0xdc, 0xdc, 0xd7, 0xd1, + 0xcf, 0xce, 0xcc, 0xcb, 0xcc, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd7, 0xd8, + 0xd8, 0xd6, 0xd9, 0xdc, 0xdd, 0xe2, 0xe8, 0xe7, 0xea, 0xeb, 0xe6, 0xe4, + 0xe8, 0xec, 0xf0, 0xf7, 0xf9, 0x7a, 0x6f, 0x71, 0x78, 0x77, 0x79, 0xfc, + 0xfc, 0xf9, 0xf3, 0xf2, 0xeb, 0xe0, 0xdd, 0xdd, 0xda, 0xd8, 0xdb, 0xde, + 0xdf, 0xe5, 0xef, 0xf7, 0xf9, 0x7c, 0x79, 0x7a, 0x6e, 0x6b, 0x68, 0x61, + 0x5d, 0x5a, 0x58, 0x57, 0x55, 0x54, 0x53, 0x52, 0x4f, 0x4e, 0x4e, 0x4d, + 0x4c, 0x4c, 0x4d, 0x4e, 0x50, 0x51, 0x50, 0x51, 0x53, 0x53, 0x53, 0x52, + 0x53, 0x54, 0x56, 0x59, 0x5c, 0x60, 0x66, 0x69, 0x6e, 0x75, 0x7c, 0xfc, + 0xf6, 0xee, 0xe9, 0xe2, 0xde, 0xdd, 0xdc, 0xdb, 0xda, 0xdb, 0xd9, 0xd7, + 0xd5, 0xd3, 0xcf, 0xce, 0xcd, 0xcd, 0xcd, 0xcc, 0xce, 0xd1, 0xd3, 0xd4, + 0xd7, 0xda, 0xdb, 0xdb, 0xdb, 0xdc, 0xdd, 0xe1, 0xe4, 0xeb, 0xf5, 0xff, + 0x76, 0x71, 0x6f, 0x6e, 0x72, 0x74, 0x6f, 0x72, 0x72, 0x6d, 0x6d, 0x6e, + 0x72, 0x7c, 0xf9, 0xea, 0xdf, 0xdb, 0xd8, 0xd6, 0xd5, 0xd6, 0xdb, 0xe0, + 0xe6, 0xee, 0xf3, 0xfc, 0x70, 0x6b, 0x6a, 0x68, 0x65, 0x60, 0x5e, 0x5b, + 0x58, 0x58, 0x57, 0x55, 0x54, 0x54, 0x56, 0x56, 0x57, 0x5a, 0x5a, 0x5b, + 0x5b, 0x59, 0x57, 0x56, 0x55, 0x55, 0x56, 0x56, 0x59, 0x5c, 0x5d, 0x5d, + 0x5d, 0x5d, 0x5c, 0x5b, 0x5c, 0x5e, 0x5e, 0x5f, 0x62, 0x64, 0x6a, 0x71, + 0x77, 0xfa, 0xee, 0xeb, 0xe8, 0xe7, 0xe4, 0xe3, 0xe3, 0xe1, 0xdf, 0xde, + 0xdc, 0xda, 0xd8, 0xd7, 0xd7, 0xd4, 0xd2, 0xd2, 0xd2, 0xd0, 0xd1, 0xd3, + 0xd2, 0xd4, 0xd7, 0xd7, 0xd6, 0xd9, 0xdb, 0xda, 0xdc, 0xdf, 0xe1, 0xe6, + 0xe9, 0xed, 0xfb, 0x75, 0x6e, 0x6a, 0x69, 0x67, 0x66, 0x6b, 0x71, 0x7d, + 0xf4, 0xed, 0xe5, 0xe2, 0xe1, 0xde, 0xde, 0xe1, 0xe8, 0xef, 0xf9, 0x79, + 0x70, 0x6d, 0x6c, 0x6d, 0x6f, 0x6e, 0x68, 0x67, 0x68, 0x60, 0x5d, 0x5d, + 0x5c, 0x5a, 0x59, 0x59, 0x5a, 0x5b, 0x5b, 0x5c, 0x5e, 0x5e, 0x5d, 0x5e, + 0x5d, 0x5d, 0x5d, 0x5d, 0x5e, 0x5f, 0x5f, 0x5e, 0x5f, 0x5f, 0x5f, 0x5f, + 0x60, 0x62, 0x64, 0x67, 0x69, 0x6b, 0x6d, 0x6d, 0x6e, 0x74, 0x7b, 0x7c, + 0xfe, 0xf8, 0xf3, 0xed, 0xe9, 0xe6, 0xe3, 0xe3, 0xe1, 0xdf, 0xe1, 0xe1, + 0xdf, 0xe0, 0xe4, 0xe5, 0xe5, 0xe7, 0xe4, 0xe2, 0xe3, 0xe0, 0xdd, 0xdb, + 0xda, 0xd8, 0xd7, 0xd7, 0xd6, 0xd6, 0xd7, 0xd8, 0xda, 0xde, 0xdf, 0xdf, + 0xe3, 0xe7, 0xe5, 0xe2, 0xe0, 0xe3, 0xe7, 0xe7, 0xe9, 0xed, 0xf6, 0x7e, + 0x79, 0x73, 0x6e, 0x6e, 0x6d, 0x6c, 0x6b, 0x67, 0x67, 0x6a, 0x68, 0x67, + 0x67, 0x65, 0x64, 0x64, 0x64, 0x63, 0x64, 0x66, 0x66, 0x68, 0x69, 0x67, + 0x67, 0x67, 0x67, 0x67, 0x65, 0x66, 0x68, 0x69, 0x69, 0x6d, 0x6d, 0x6b, + 0x6d, 0x6d, 0x6c, 0x6b, 0x69, 0x6d, 0x6e, 0x6c, 0x6a, 0x6a, 0x6b, 0x68, + 0x68, 0x6b, 0x6a, 0x6a, 0x6f, 0x73, 0x6f, 0x72, 0x77, 0x75, 0x75, 0x78, + 0x7b, 0x7a, 0xfe, 0xfb, 0xf9, 0xf5, 0xf4, 0xed, 0xe9, 0xea, 0xe9, 0xe6, + 0xe3, 0xe3, 0xe4, 0xe0, 0xdf, 0xe2, 0xe4, 0xe3, 0xe3, 0xe7, 0xe6, 0xe2, + 0xe2, 0xe4, 0xe2, 0xe0, 0xdf, 0xdf, 0xdf, 0xdf, 0xde, 0xde, 0xdf, 0xe3, + 0xe2, 0xe1, 0xe8, 0xed, 0xee, 0xee, 0xf0, 0xf5, 0xf6, 0xf6, 0xf8, 0xfd, + 0xfd, 0xfc, 0xff, 0x78, 0x73, 0x74, 0x74, 0x71, 0x71, 0x72, 0x75, 0x79, + 0x7b, 0x7e, 0xfb, 0xf5, 0xf5, 0xfa, 0xfd, 0x7e, 0x75, 0x70, 0x70, 0x70, + 0x70, 0x70, 0x6f, 0x70, 0x75, 0x71, 0x6f, 0x70, 0x6f, 0x6c, 0x6b, 0x6b, + 0x6b, 0x6a, 0x68, 0x68, 0x67, 0x67, 0x67, 0x66, 0x68, 0x69, 0x67, 0x69, + 0x68, 0x67, 0x6a, 0x6a, 0x6b, 0x6b, 0x6c, 0x6e, 0x6c, 0x6a, 0x6a, 0x6c, + 0x6b, 0x6a, 0x6d, 0x6f, 0x6f, 0x6f, 0x70, 0x72, 0x72, 0x76, 0x7c, 0xfd, + 0xf5, 0xf0, 0xf2, 0xf4, 0xf2, 0xf0, 0xf1, 0xf9, 0xfb, 0xf1, 0xf1, 0xf2, + 0xec, 0xe8, 0xe7, 0xe4, 0xdf, 0xde, 0xdc, 0xd9, 0xd8, 0xd8, 0xd8, 0xd7, + 0xd8, 0xda, 0xdb, 0xde, 0xe2, 0xe3, 0xe4, 0xe4, 0xe6, 0xe8, 0xe7, 0xe7, + 0xe9, 0xec, 0xef, 0xf2, 0xf3, 0xfb, 0x79, 0x76, 0x77, 0x76, 0x70, 0x6f, + 0x6f, 0x6c, 0x6d, 0x6e, 0x6f, 0x71, 0x70, 0x75, 0x7e, 0x7c, 0x77, 0xfe, + 0xf5, 0xf8, 0xf9, 0xf8, 0xfa, 0xfb, 0xfe, 0xfb, 0xfa, 0x7d, 0xfd, 0xfa, + 0xf9, 0xfd, 0x7b, 0x7c, 0x77, 0x72, 0x72, 0x70, 0x6d, 0x6b, 0x69, 0x66, + 0x67, 0x65, 0x63, 0x62, 0x60, 0x62, 0x63, 0x62, 0x62, 0x61, 0x62, 0x61, + 0x60, 0x61, 0x60, 0x61, 0x61, 0x61, 0x63, 0x66, 0x67, 0x68, 0x6b, 0x6d, + 0x6e, 0x74, 0x7b, 0xfd, 0xfa, 0xf7, 0xf2, 0xef, 0xee, 0xee, 0xed, 0xec, + 0xea, 0xe9, 0xe8, 0xe6, 0xe6, 0xe7, 0xe9, 0xeb, 0xea, 0xe9, 0xe6, 0xe4, + 0xe3, 0xe0, 0xdf, 0xde, 0xdd, 0xde, 0xdd, 0xdd, 0xdd, 0xde, 0xde, 0xe0, + 0xe2, 0xe4, 0xe9, 0xe8, 0xe6, 0xe9, 0xeb, 0xeb, 0xeb, 0xef, 0xf2, 0xf0, + 0xf4, 0xfa, 0xfe, 0x77, 0x74, 0x74, 0x71, 0x6f, 0x6f, 0x71, 0x6f, 0x6e, + 0x71, 0x73, 0x76, 0x7c, 0xff, 0xfe, 0xfa, 0xfb, 0xfb, 0xf5, 0xf5, 0xfa, + 0xfb, 0xfc, 0xfe, 0x7e, 0xff, 0x79, 0x74, 0x76, 0x79, 0x75, 0x74, 0x7a, + 0x78, 0x75, 0x75, 0x72, 0x6f, 0x6d, 0x6d, 0x6d, 0x69, 0x65, 0x63, 0x63, + 0x61, 0x5e, 0x5f, 0x60, 0x60, 0x60, 0x61, 0x5f, 0x5e, 0x5f, 0x5f, 0x60, + 0x63, 0x65, 0x68, 0x69, 0x6a, 0x6c, 0x6c, 0x6e, 0x70, 0x76, 0x7b, 0xfe, + 0xf5, 0xef, 0xef, 0xef, 0xec, 0xea, 0xeb, 0xe9, 0xe8, 0xec, 0xf0, 0xf4, + 0xef, 0xeb, 0xe9, 0xea, 0xe6, 0xe0, 0xde, 0xdd, 0xdc, 0xda, 0xd9, 0xd9, + 0xdb, 0xdd, 0xdd, 0xde, 0xe2, 0xe2, 0xe1, 0xe3, 0xe6, 0xe5, 0xe4, 0xe6, + 0xe7, 0xe7, 0xe9, 0xed, 0xef, 0xf6, 0xfe, 0xff, 0x7b, 0x72, 0x72, 0x73, + 0x6f, 0x6e, 0x6f, 0x73, 0x6f, 0x6d, 0x6c, 0x6b, 0x6a, 0x6a, 0x6e, 0x73, + 0x75, 0x7a, 0x7e, 0xfa, 0xf7, 0xf2, 0xef, 0xee, 0xee, 0xf0, 0xf2, 0xf4, + 0xf9, 0xf9, 0xfc, 0xfe, 0x7d, 0x79, 0x77, 0x72, 0x73, 0x71, 0x6d, 0x6d, + 0x6d, 0x68, 0x65, 0x67, 0x66, 0x60, 0x5f, 0x5e, 0x5f, 0x5e, 0x5d, 0x5d, + 0x5e, 0x5e, 0x5e, 0x5e, 0x60, 0x61, 0x62, 0x66, 0x66, 0x64, 0x67, 0x69, + 0x66, 0x67, 0x6a, 0x6b, 0x6a, 0x6c, 0x71, 0x72, 0x74, 0x76, 0x75, 0x7a, + 0x79, 0x7a, 0xf8, 0xef, 0xeb, 0xe7, 0xdf, 0xdc, 0xda, 0xd7, 0xd4, 0xd2, + 0xd0, 0xd0, 0xd1, 0xd3, 0xd3, 0xd6, 0xda, 0xdd, 0xde, 0xdf, 0xe5, 0xe5, + 0xe5, 0xe9, 0xeb, 0xeb, 0xef, 0xf2, 0xf5, 0x7d, 0x72, 0x6f, 0x6e, 0x6d, + 0x6c, 0x6e, 0x73, 0x72, 0x72, 0x73, 0x75, 0x78, 0x77, 0x74, 0x74, 0x72, + 0x72, 0x73, 0x6f, 0x6f, 0x72, 0x74, 0x7d, 0xf3, 0xef, 0xec, 0xe7, 0xe5, + 0xe6, 0xe6, 0xe7, 0xe9, 0xea, 0xee, 0xfa, 0xfd, 0xfd, 0x7a, 0x79, 0xfe, + 0xfd, 0x78, 0x74, 0x71, 0x6b, 0x66, 0x65, 0x65, 0x5f, 0x5e, 0x5f, 0x5e, + 0x5d, 0x5d, 0x5e, 0x5e, 0x5d, 0x5e, 0x5e, 0x5f, 0x5f, 0x5e, 0x5d, 0x5d, + 0x5d, 0x5d, 0x5d, 0x5d, 0x5c, 0x5c, 0x5c, 0x5e, 0x5e, 0x5e, 0x60, 0x5f, + 0x62, 0x67, 0x68, 0x6d, 0xfd, 0xee, 0xe7, 0xdd, 0xd6, 0xd2, 0xcf, 0xcd, + 0xcb, 0xcb, 0xcb, 0xca, 0xcb, 0xcd, 0xcf, 0xd0, 0xd4, 0xd8, 0xdb, 0xdf, + 0xe9, 0xea, 0xed, 0xfc, 0x7b, 0x7a, 0x71, 0x6b, 0x68, 0x65, 0x60, 0x5f, + 0x5f, 0x5f, 0x5f, 0x63, 0x67, 0x6b, 0x77, 0xf8, 0xef, 0xec, 0xe8, 0xe5, + 0xe6, 0xe9, 0xed, 0xf4, 0xfe, 0x76, 0x6f, 0x6f, 0x72, 0x79, 0xfb, 0xee, + 0xe7, 0xe2, 0xdf, 0xde, 0xde, 0xe0, 0xe7, 0xef, 0xfd, 0x74, 0x6e, 0x71, + 0x72, 0x75, 0x7c, 0xfc, 0xfa, 0x7e, 0x77, 0x6f, 0x67, 0x60, 0x5d, 0x5a, + 0x58, 0x58, 0x57, 0x57, 0x5a, 0x5b, 0x5b, 0x5c, 0x5c, 0x5c, 0x59, 0x59, + 0x59, 0x57, 0x56, 0x55, 0x55, 0x55, 0x56, 0x56, 0x57, 0x5a, 0x5b, 0x5d, + 0x61, 0x64, 0x64, 0x68, 0x6f, 0x7c, 0xee, 0xe4, 0xdc, 0xd3, 0xce, 0xcc, + 0xc9, 0xc6, 0xc5, 0xc5, 0xc5, 0xc6, 0xc9, 0xcb, 0xce, 0xd4, 0xd8, 0xdc, + 0xe5, 0xed, 0xf4, 0xfd, 0x73, 0x6a, 0x66, 0x64, 0x5f, 0x5d, 0x5c, 0x5b, + 0x5c, 0x5c, 0x5d, 0x64, 0x6f, 0x7b, 0xf7, 0xe6, 0xdf, 0xdf, 0xdc, 0xdb, + 0xdc, 0xdf, 0xe5, 0xe9, 0xf2, 0xfe, 0x74, 0x6b, 0x6a, 0x68, 0x63, 0x61, + 0x65, 0x67, 0x63, 0x63, 0x67, 0x6c, 0x73, 0x7c, 0xef, 0xe3, 0xdf, 0xdc, + 0xd8, 0xd4, 0xd4, 0xd6, 0xd8, 0xdb, 0xe0, 0xe8, 0xf7, 0x6e, 0x66, 0x5e, + 0x5a, 0x59, 0x58, 0x59, 0x57, 0x57, 0x59, 0x58, 0x56, 0x55, 0x54, 0x53, + 0x50, 0x50, 0x51, 0x53, 0x54, 0x55, 0x57, 0x58, 0x57, 0x55, 0x54, 0x53, + 0x51, 0x4f, 0x50, 0x50, 0x50, 0x52, 0x52, 0x57, 0x69, 0x7c, 0xfa, 0xd8, + 0xca, 0xc9, 0xc7, 0xbf, 0xbf, 0xc0, 0xbf, 0xc1, 0xc4, 0xc5, 0xca, 0xce, + 0xcf, 0xd2, 0xd7, 0xe1, 0xe6, 0xe6, 0x74, 0x60, 0x63, 0x5c, 0x53, 0x52, + 0x52, 0x53, 0x58, 0x5c, 0x5f, 0x74, 0xe6, 0xde, 0xdd, 0xd7, 0xd1, 0xd5, + 0xd9, 0xd7, 0xda, 0xe2, 0xe2, 0xe6, 0xee, 0xf6, 0x77, 0x6a, 0x65, 0x5f, + 0x58, 0x51, 0x50, 0x4f, 0x4d, 0x4c, 0x4f, 0x53, 0x56, 0x60, 0x7a, 0xec, + 0xdf, 0xd6, 0xd0, 0xcd, 0xcc, 0xcc, 0xcb, 0xcb, 0xcd, 0xcf, 0xd3, 0xd6, + 0xdd, 0xe9, 0xf1, 0x76, 0x63, 0x5d, 0x58, 0x53, 0x52, 0x50, 0x4e, 0x4f, + 0x51, 0x51, 0x4f, 0x52, 0x57, 0x56, 0x53, 0x55, 0x57, 0x55, 0x54, 0x54, + 0x53, 0x51, 0x4f, 0x4d, 0x4e, 0x4d, 0x4b, 0x4a, 0x4c, 0x4c, 0x4b, 0x4c, + 0x4d, 0x4d, 0x56, 0x7a, 0xf8, 0xde, 0xc6, 0xc0, 0xc1, 0xbb, 0xb8, 0xbb, + 0xbc, 0xbd, 0xc1, 0xc5, 0xca, 0xce, 0xd5, 0xd8, 0xd8, 0xee, 0x75, 0xf0, + 0x62, 0x51, 0x55, 0x52, 0x4d, 0x4f, 0x55, 0x5c, 0x6e, 0xe7, 0xd8, 0xd2, + 0xcb, 0xc9, 0xce, 0xcd, 0xcc, 0xd6, 0xde, 0xdc, 0xe1, 0xf0, 0xfd, 0x75, + 0x69, 0x5d, 0x56, 0x4e, 0x4b, 0x4a, 0x47, 0x44, 0x49, 0x4e, 0x4f, 0x58, + 0x6e, 0xef, 0xe4, 0xdb, 0xd5, 0xd2, 0xcf, 0xce, 0xd0, 0xcd, 0xc8, 0xcc, + 0xcd, 0xc9, 0xcd, 0xd9, 0xdf, 0xf4, 0x61, 0x58, 0x56, 0x51, 0x51, 0x57, + 0x58, 0x59, 0x66, 0x67, 0x5d, 0x5e, 0x61, 0x59, 0x54, 0x56, 0x54, 0x52, + 0x51, 0x51, 0x4f, 0x4f, 0x4d, 0x48, 0x46, 0x45, 0x3f, 0x3e, 0x3f, 0x40, + 0x41, 0x44, 0x49, 0x4c, 0x4e, 0x4f, 0x53, 0xfe, 0xd3, 0xd5, 0xc7, 0xb7, + 0xb7, 0xb9, 0xb4, 0xb5, 0xb9, 0xbd, 0xc7, 0xce, 0xd7, 0xef, 0x66, 0x5f, + 0x7d, 0x64, 0x4e, 0x5c, 0x5e, 0x4c, 0x4e, 0x53, 0x58, 0x6f, 0xed, 0xd7, + 0xc9, 0xc1, 0xbf, 0xc4, 0xbf, 0xc0, 0xcf, 0xd7, 0xd5, 0xe8, 0x76, 0x67, + 0x62, 0x61, 0x58, 0x4f, 0x4b, 0x4a, 0x49, 0x42, 0x44, 0x4d, 0x4f, 0x58, + 0xf7, 0xdb, 0xd3, 0xd1, 0xd2, 0xd3, 0xd4, 0xd6, 0xe0, 0xdd, 0xcf, 0xd3, + 0xdb, 0xcf, 0xcf, 0xdd, 0xed, 0xfb, 0x6d, 0x5f, 0x5a, 0x5c, 0x68, 0xf9, + 0xff, 0xfc, 0xde, 0xe2, 0x6e, 0x69, 0x69, 0x5d, 0x56, 0x54, 0x56, 0x55, + 0x52, 0x4d, 0x49, 0x49, 0x43, 0x3e, 0x3e, 0x3f, 0x3d, 0x3c, 0x3e, 0x41, + 0x41, 0x41, 0x43, 0x48, 0x4a, 0x49, 0x4b, 0x51, 0x72, 0xcd, 0xc6, 0xbf, + 0xb3, 0xb1, 0xb7, 0xb6, 0xb8, 0xc0, 0xcb, 0xd7, 0xe6, 0xea, 0xf8, 0x6e, + 0x66, 0xfc, 0x6a, 0x4b, 0x4f, 0x59, 0x4c, 0x53, 0xfd, 0xdb, 0xca, 0xc3, + 0xbf, 0xbd, 0xbd, 0xc1, 0xcd, 0xce, 0xcf, 0xfb, 0xf9, 0xe5, 0xfe, 0x77, + 0x63, 0x59, 0x53, 0x4c, 0x47, 0x44, 0x4b, 0x55, 0x55, 0x78, 0xd4, 0xd1, + 0xcf, 0xd1, 0xd6, 0xda, 0xea, 0x72, 0x7b, 0xe8, 0xe8, 0xec, 0xdc, 0xdc, + 0xf9, 0x70, 0x6b, 0x60, 0x61, 0x6d, 0xef, 0xdf, 0xd4, 0xd1, 0xd4, 0xd3, + 0xdb, 0x7d, 0x6d, 0x65, 0x59, 0x57, 0x5d, 0x5f, 0x5b, 0x58, 0x50, 0x4a, + 0x46, 0x40, 0x3c, 0x3d, 0x3d, 0x3c, 0x3e, 0x40, 0x3f, 0x3e, 0x3e, 0x3d, + 0x3d, 0x3e, 0x41, 0x45, 0x4b, 0x57, 0x5e, 0xdc, 0xbf, 0xbf, 0xbf, 0xb3, + 0xb2, 0xbb, 0xb9, 0xbc, 0xc5, 0xca, 0xd9, 0xf0, 0xe9, 0xee, 0x5c, 0x52, + 0x6c, 0x5b, 0x4a, 0x5a, 0x6f, 0x6b, 0xdc, 0xce, 0xc8, 0xbf, 0xbe, 0xc2, + 0xc2, 0xc0, 0xca, 0xdb, 0xd2, 0xd9, 0x76, 0x7e, 0x6c, 0x5e, 0x5b, 0x4f, + 0x4b, 0x4e, 0x53, 0x4f, 0x56, 0xeb, 0xdf, 0xe0, 0xd1, 0xcf, 0xd3, 0xd7, + 0xe2, 0xe9, 0xe2, 0xe6, 0x7d, 0xf3, 0xe1, 0xf9, 0x67, 0x6a, 0x64, 0x61, + 0x66, 0x6a, 0xf0, 0xdb, 0xdc, 0xdf, 0xd8, 0xda, 0xf7, 0x70, 0x76, 0x68, + 0x61, 0x61, 0x5d, 0x5e, 0x5c, 0x4f, 0x4b, 0x4b, 0x46, 0x3f, 0x3f, 0x40, + 0x3e, 0x3d, 0x3e, 0x3d, 0x3c, 0x3c, 0x3a, 0x3b, 0x3e, 0x3f, 0x41, 0x49, + 0x4e, 0x4f, 0x51, 0xf0, 0xc2, 0xbe, 0xbd, 0xb1, 0xaf, 0xb6, 0xb9, 0xbd, + 0xc9, 0xcf, 0xec, 0x6c, 0xea, 0xe5, 0x6b, 0x59, 0x6e, 0x62, 0x4a, 0x51, + 0x65, 0x7b, 0xd2, 0xcb, 0xc2, 0xbb, 0xbc, 0xc2, 0xc6, 0xc8, 0xd4, 0xff, + 0xec, 0xeb, 0x72, 0x6e, 0x5d, 0x5a, 0x57, 0x4a, 0x47, 0x4d, 0x57, 0x5c, + 0x79, 0xd3, 0xcc, 0xcc, 0xcd, 0xd4, 0xd5, 0xdb, 0xef, 0xdf, 0xd4, 0xd7, + 0xde, 0xdd, 0xe4, 0x6c, 0x60, 0x5d, 0x5e, 0x73, 0xfe, 0xf1, 0xdc, 0xd9, + 0xeb, 0xfc, 0xf3, 0x6b, 0x5c, 0x5e, 0x5f, 0x5e, 0x5c, 0x54, 0x4e, 0x4a, + 0x43, 0x3e, 0x3d, 0x3e, 0x3c, 0x3c, 0x3d, 0x3c, 0x3a, 0x38, 0x36, 0x37, + 0x3a, 0x3c, 0x3e, 0x49, 0x53, 0x50, 0x5e, 0xcc, 0xbc, 0xbc, 0xb8, 0xae, + 0xaf, 0xb8, 0xba, 0xc1, 0xca, 0xd2, 0x68, 0x68, 0xe5, 0x77, 0x57, 0x59, + 0x72, 0x59, 0x4e, 0x6d, 0xe4, 0xd1, 0xc6, 0xc4, 0xbc, 0xba, 0xc0, 0xc9, + 0xcb, 0xce, 0xef, 0x63, 0x6f, 0x64, 0x5b, 0x52, 0x4b, 0x4f, 0x4d, 0x46, + 0x4c, 0x61, 0xfd, 0xe7, 0xd1, 0xc8, 0xc8, 0xca, 0xcf, 0xd4, 0xd0, 0xd7, + 0xde, 0xd5, 0xd1, 0xdc, 0xe9, 0xf6, 0x71, 0x69, 0x61, 0x65, 0xeb, 0xde, + 0xe6, 0xe2, 0xdb, 0xe4, 0x76, 0x6e, 0x6c, 0x65, 0x61, 0x5a, 0x57, 0x54, + 0x4a, 0x42, 0x3e, 0x3c, 0x39, 0x37, 0x37, 0x37, 0x36, 0x36, 0x34, 0x34, + 0x36, 0x36, 0x39, 0x3d, 0x43, 0x4a, 0x78, 0xbc, 0xb6, 0xb8, 0xae, 0xac, + 0xb5, 0xb9, 0xbe, 0xc9, 0xca, 0xdb, 0x76, 0xe9, 0xec, 0x55, 0x46, 0x4f, + 0x50, 0x48, 0x5e, 0xdb, 0xcb, 0xbd, 0xbd, 0xbd, 0xb8, 0xbd, 0xc8, 0xcb, + 0xca, 0xd3, 0xf4, 0xf1, 0x6b, 0x53, 0x4c, 0x40, 0x3f, 0x45, 0x42, 0x46, + 0x5b, 0xef, 0xde, 0xd4, 0xcd, 0xcb, 0xcb, 0xce, 0xcf, 0xc7, 0xc4, 0xcb, + 0xcb, 0xca, 0xd5, 0xf0, 0x6d, 0x65, 0x6a, 0x6d, 0x69, 0xf1, 0xda, 0xe6, + 0x78, 0xef, 0xf2, 0x68, 0x66, 0x6b, 0x69, 0x65, 0x57, 0x4c, 0x48, 0x3f, + 0x3a, 0x37, 0x36, 0x34, 0x33, 0x33, 0x33, 0x32, 0x30, 0x2f, 0x33, 0x36, + 0x37, 0x41, 0xce, 0xb7, 0xb7, 0xaf, 0xaa, 0xae, 0xb8, 0xbd, 0xc8, 0xc8, + 0xcc, 0xf0, 0xde, 0xd2, 0x64, 0x46, 0x45, 0x49, 0x43, 0x4a, 0xfa, 0xce, + 0xbc, 0xb9, 0xbc, 0xb7, 0xb9, 0xc5, 0xcb, 0xc7, 0xc9, 0xd4, 0xdd, 0xeb, + 0x5f, 0x4e, 0x3f, 0x3c, 0x41, 0x43, 0x43, 0x58, 0xe2, 0xda, 0xd5, 0xcf, + 0xce, 0xcc, 0xcc, 0xcb, 0xc4, 0xbf, 0xc2, 0xca, 0xcb, 0xd6, 0x69, 0x59, + 0x58, 0x58, 0x5f, 0x67, 0xfc, 0xde, 0xe5, 0x73, 0x71, 0xf9, 0x6e, 0x63, + 0x79, 0x7c, 0x62, 0x52, 0x45, 0x3e, 0x3a, 0x34, 0x32, 0x32, 0x32, 0x31, + 0x32, 0x32, 0x31, 0x31, 0x33, 0x35, 0x3f, 0xd7, 0xba, 0xb7, 0xaf, 0xaa, + 0xaf, 0xb9, 0xbf, 0xce, 0xd0, 0xd3, 0xee, 0xdb, 0xd8, 0x5f, 0x48, 0x44, + 0x45, 0x42, 0x4d, 0xe7, 0xc9, 0xbb, 0xb8, 0xba, 0xb8, 0xbb, 0xc8, 0xcb, + 0xca, 0xcd, 0xd6, 0xdd, 0xf8, 0x59, 0x49, 0x3d, 0x3c, 0x40, 0x43, 0x49, + 0x6b, 0xda, 0xd3, 0xce, 0xce, 0xcc, 0xc4, 0xc5, 0xc6, 0xbd, 0xbb, 0xc1, + 0xc8, 0xcf, 0xe7, 0x62, 0x53, 0x4f, 0x5b, 0x6d, 0x62, 0x72, 0xe3, 0x6e, + 0x59, 0x5c, 0x5b, 0x57, 0x54, 0x50, 0x4c, 0x46, 0x3d, 0x37, 0x34, 0x31, + 0x2e, 0x2e, 0x2f, 0x2f, 0x2f, 0x31, 0x34, 0x37, 0x45, 0xcc, 0xbc, 0xb8, + 0xad, 0xac, 0xb1, 0xb6, 0xbf, 0xca, 0xc9, 0xd8, 0xeb, 0xd6, 0xde, 0x56, + 0x49, 0x4a, 0x48, 0x47, 0x5b, 0xdf, 0xc6, 0xba, 0xbc, 0xbb, 0xb8, 0xbe, + 0xca, 0xcb, 0xcd, 0xd3, 0xdf, 0xfc, 0x5e, 0x50, 0x46, 0x3d, 0x3e, 0x43, + 0x45, 0x4e, 0x7e, 0xd8, 0xce, 0xcc, 0xc7, 0xbf, 0xbf, 0xc1, 0xbe, 0xbb, + 0xbd, 0xc6, 0xcd, 0xd2, 0xef, 0x59, 0x51, 0x53, 0x5c, 0x5b, 0x5a, 0x75, + 0x7b, 0x5e, 0x58, 0x59, 0x57, 0x4d, 0x48, 0x44, 0x3f, 0x3a, 0x34, 0x30, + 0x2f, 0x2d, 0x2c, 0x2d, 0x2e, 0x30, 0x31, 0x3a, 0xdd, 0xbf, 0xbf, 0xb3, + 0xad, 0xb2, 0xb8, 0xbd, 0xc7, 0xc4, 0xcb, 0xee, 0xd9, 0xd7, 0x56, 0x46, + 0x4a, 0x4b, 0x4a, 0x5b, 0xdd, 0xc9, 0xbb, 0xbc, 0xbe, 0xb7, 0xbc, 0xc8, + 0xc6, 0xc6, 0xcd, 0xd9, 0xfa, 0x5d, 0x52, 0x46, 0x3d, 0x3f, 0x47, 0x46, + 0x4b, 0x6d, 0xe1, 0xd8, 0xce, 0xca, 0xc2, 0xbd, 0xc0, 0xbf, 0xbb, 0xbe, + 0xc9, 0xcf, 0xda, 0xfb, 0x5c, 0x53, 0x55, 0x5f, 0x5e, 0x59, 0x6e, 0xff, + 0x5c, 0x56, 0x57, 0x50, 0x4a, 0x42, 0x3d, 0x3b, 0x37, 0x30, 0x2e, 0x2f, + 0x2d, 0x2c, 0x2f, 0x30, 0x33, 0x4e, 0xc8, 0xc5, 0xb9, 0xae, 0xb3, 0xb9, + 0xba, 0xca, 0xcc, 0xc8, 0xef, 0xf1, 0xd4, 0x62, 0x49, 0x4c, 0x4c, 0x46, + 0x56, 0xe6, 0xd2, 0xbe, 0xbb, 0xbe, 0xb9, 0xba, 0xc6, 0xc7, 0xc6, 0xcf, + 0xda, 0xeb, 0x5b, 0x4f, 0x49, 0x3d, 0x3d, 0x43, 0x43, 0x49, 0x65, 0xe2, + 0xd1, 0xc8, 0xc6, 0xbf, 0xbb, 0xbd, 0xbe, 0xba, 0xbc, 0xc5, 0xcb, 0xd6, + 0xf8, 0x64, 0x58, 0x55, 0x61, 0x66, 0x5b, 0x6c, 0xf6, 0x5c, 0x54, 0x53, + 0x4a, 0x44, 0x3d, 0x38, 0x35, 0x31, 0x2e, 0x2d, 0x2d, 0x2d, 0x2e, 0x30, + 0x3b, 0xdf, 0xca, 0xc7, 0xb2, 0xb0, 0xbc, 0xbd, 0xc5, 0xcf, 0xca, 0xdc, + 0xfd, 0xd3, 0xe0, 0x4f, 0x4c, 0x54, 0x4c, 0x4d, 0xef, 0xcf, 0xc2, 0xba, + 0xbc, 0xba, 0xb7, 0xc1, 0xcb, 0xc5, 0xcc, 0xdb, 0xe8, 0x6b, 0x56, 0x4b, + 0x3f, 0x3c, 0x41, 0x44, 0x44, 0x54, 0xe2, 0xd5, 0xcd, 0xc8, 0xc3, 0xbf, + 0xbf, 0xc1, 0xbe, 0xbd, 0xc5, 0xce, 0xd3, 0xe9, 0x5c, 0x54, 0x54, 0x5a, + 0x64, 0x63, 0x7c, 0xe5, 0x70, 0x57, 0x51, 0x4c, 0x40, 0x39, 0x35, 0x34, + 0x31, 0x2d, 0x2d, 0x2f, 0x2f, 0x2f, 0x3f, 0xd9, 0xcd, 0xc3, 0xb3, 0xb4, + 0xbb, 0xbe, 0xcf, 0xd4, 0xcc, 0x75, 0x6c, 0xd5, 0x71, 0x4c, 0x4e, 0x4f, + 0x4b, 0x51, 0x78, 0xd4, 0xbf, 0xbb, 0xbd, 0xb8, 0xb7, 0xc3, 0xca, 0xc9, + 0xd3, 0xdf, 0xfa, 0x5d, 0x5a, 0x4e, 0x3f, 0x3f, 0x46, 0x44, 0x46, 0x5b, + 0xe0, 0xcd, 0xc7, 0xc5, 0xbf, 0xbd, 0xc2, 0xc5, 0xbf, 0xc2, 0xca, 0xce, + 0xd5, 0xec, 0x60, 0x54, 0x51, 0x59, 0x5b, 0x58, 0x69, 0xf9, 0x5c, 0x4e, + 0x49, 0x41, 0x3a, 0x33, 0x2f, 0x30, 0x2e, 0x2c, 0x2f, 0x34, 0x39, 0x5a, + 0xd1, 0xce, 0xba, 0xb5, 0xbe, 0xbd, 0xbf, 0xd5, 0xd0, 0xd6, 0x7a, 0xe8, + 0xf6, 0x52, 0x4e, 0x54, 0x4d, 0x4e, 0xf3, 0xd3, 0xc8, 0xbc, 0xba, 0xb9, + 0xb8, 0xbe, 0xc5, 0xc5, 0xd0, 0xee, 0xf9, 0x5f, 0x4f, 0x4b, 0x43, 0x3f, + 0x41, 0x41, 0x43, 0x4e, 0x73, 0xdc, 0xcc, 0xc1, 0xbe, 0xbd, 0xbd, 0xc1, + 0xc1, 0xc3, 0xce, 0xd5, 0xd9, 0x7b, 0x5d, 0x58, 0x51, 0x50, 0x53, 0x56, + 0x5f, 0x6d, 0x5c, 0x50, 0x4d, 0x43, 0x3a, 0x34, 0x2f, 0x2e, 0x2e, 0x2e, + 0x32, 0x3b, 0x5f, 0xd0, 0xcf, 0xbc, 0xb7, 0xc4, 0xc5, 0xc6, 0xd8, 0xcf, + 0xd5, 0xf8, 0xda, 0xf5, 0x4d, 0x4d, 0x4e, 0x48, 0x4b, 0x78, 0xd1, 0xc6, + 0xbc, 0xba, 0xb9, 0xb8, 0xbf, 0xc7, 0xc5, 0xcf, 0xef, 0xee, 0x6c, 0x55, + 0x4c, 0x42, 0x3f, 0x42, 0x3f, 0x43, 0x57, 0xeb, 0xd6, 0xc7, 0xbe, 0xbc, + 0xbb, 0xbe, 0xbf, 0xbe, 0xc6, 0xd1, 0xcf, 0xdb, 0x67, 0x57, 0x50, 0x4e, + 0x4d, 0x4c, 0x4f, 0x57, 0x55, 0x4d, 0x4b, 0x45, 0x3a, 0x32, 0x2f, 0x2e, + 0x2d, 0x2f, 0x34, 0x42, 0xdd, 0xca, 0xc9, 0xb9, 0xba, 0xcb, 0xcb, 0xce, + 0xdf, 0xd4, 0xdf, 0xe7, 0xda, 0x62, 0x4b, 0x4c, 0x4b, 0x48, 0x52, 0xdd, + 0xc7, 0xbe, 0xb9, 0xb7, 0xb6, 0xb9, 0xc3, 0xc8, 0xc8, 0xd8, 0xf0, 0xef, + 0x69, 0x55, 0x4a, 0x41, 0x42, 0x42, 0x40, 0x4b, 0x74, 0xd5, 0xc9, 0xbf, + 0xb9, 0xb9, 0xbd, 0xbe, 0xc0, 0xc9, 0xd2, 0xda, 0xde, 0x7c, 0x55, 0x4e, + 0x4d, 0x47, 0x44, 0x47, 0x4a, 0x4a, 0x47, 0x43, 0x3f, 0x37, 0x2f, 0x2e, + 0x2e, 0x2e, 0x31, 0x3d, 0x78, 0xc5, 0xc5, 0xbb, 0xb5, 0xc0, 0xce, 0xcd, + 0xde, 0xdf, 0xdf, 0xed, 0xd3, 0xde, 0x53, 0x4e, 0x4e, 0x48, 0x49, 0x62, + 0xcf, 0xc1, 0xbb, 0xb7, 0xb5, 0xb7, 0xbf, 0xca, 0xc9, 0xd6, 0x6d, 0xfb, + 0xfb, 0x5e, 0x53, 0x48, 0x43, 0x42, 0x3e, 0x43, 0x5c, 0xe2, 0xcd, 0xbd, + 0xb7, 0xb9, 0xbb, 0xbc, 0xc4, 0xcb, 0xd3, 0xdf, 0xdc, 0xe8, 0x67, 0x68, + 0x5c, 0x4c, 0x4a, 0x48, 0x45, 0x43, 0x42, 0x3e, 0x37, 0x31, 0x2e, 0x2c, + 0x2c, 0x2f, 0x36, 0x4e, 0xc8, 0xc1, 0xba, 0xb0, 0xba, 0xc6, 0xc9, 0xe7, + 0x72, 0xf5, 0x66, 0xeb, 0xdf, 0x5d, 0x52, 0x50, 0x47, 0x44, 0x4f, 0xea, + 0xcb, 0xbe, 0xb7, 0xb3, 0xb3, 0xb8, 0xc1, 0xc8, 0xd8, 0x63, 0x5f, 0x63, + 0x59, 0x53, 0x4d, 0x49, 0x45, 0x40, 0x46, 0x56, 0x73, 0xcb, 0xbb, 0xb8, + 0xb6, 0xb5, 0xbb, 0xc2, 0xcb, 0xdd, 0xf5, 0x7e, 0x6b, 0x69, 0x6b, 0x5c, + 0x51, 0x4c, 0x44, 0x3e, 0x3d, 0x39, 0x31, 0x30, 0x30, 0x2d, 0x2e, 0x33, + 0x35, 0x48, 0xcc, 0xc8, 0xbd, 0xb0, 0xb9, 0xc1, 0xbf, 0xdc, 0x71, 0xf6, + 0x53, 0x5d, 0xf3, 0x55, 0x53, 0x5c, 0x4c, 0x4b, 0x5b, 0xee, 0xce, 0xbf, + 0xb8, 0xb3, 0xb0, 0xb4, 0xba, 0xbd, 0xcc, 0x71, 0x60, 0x55, 0x4b, 0x4c, + 0x49, 0x46, 0x49, 0x4b, 0x4b, 0x59, 0xde, 0xcb, 0xc2, 0xb9, 0xb6, 0xb8, + 0xbb, 0xbf, 0xcc, 0xdb, 0x6c, 0x5c, 0x5f, 0x57, 0x50, 0x53, 0x4e, 0x45, + 0x3e, 0x39, 0x32, 0x2e, 0x2c, 0x2c, 0x2c, 0x2e, 0x35, 0x3c, 0x6e, 0xc0, + 0xc0, 0xb8, 0xaf, 0xb9, 0xbf, 0xc1, 0xdd, 0xef, 0x7b, 0x4e, 0x5c, 0x5e, + 0x47, 0x4c, 0x51, 0x49, 0x4d, 0x69, 0xd9, 0xc7, 0xbc, 0xb6, 0xb2, 0xb1, + 0xb5, 0xbb, 0xbe, 0xcc, 0x7a, 0x66, 0x57, 0x4a, 0x4a, 0x47, 0x47, 0x51, + 0x4e, 0x51, 0xe1, 0xce, 0xcb, 0xbd, 0xb8, 0xb9, 0xb9, 0xbb, 0xc3, 0xcb, + 0xdc, 0x64, 0x69, 0x5e, 0x4d, 0x4f, 0x50, 0x43, 0x3e, 0x37, 0x2e, 0x2c, + 0x2a, 0x29, 0x2a, 0x2e, 0x32, 0x3c, 0xe0, 0xbe, 0xbe, 0xb4, 0xae, 0xb9, + 0xbd, 0xc2, 0xe8, 0xeb, 0x69, 0x4b, 0x60, 0x58, 0x43, 0x4d, 0x4d, 0x45, + 0x4d, 0x64, 0xd9, 0xc4, 0xbc, 0xb5, 0xaf, 0xaf, 0xb5, 0xb9, 0xbd, 0xce, + 0xfd, 0x6a, 0x52, 0x4b, 0x4b, 0x48, 0x52, 0x59, 0x4e, 0x7c, 0xd3, 0xda, + 0xc6, 0xbb, 0xbc, 0xbb, 0xbb, 0xbf, 0xc5, 0xd0, 0xfe, 0x6a, 0x5f, 0x4e, + 0x4c, 0x4f, 0x46, 0x3d, 0x37, 0x2e, 0x2c, 0x2a, 0x27, 0x29, 0x2e, 0x2f, + 0x3c, 0xcf, 0xbd, 0xbc, 0xb0, 0xae, 0xb7, 0xbb, 0xc4, 0xdd, 0xdf, 0x5c, + 0x4c, 0x6b, 0x52, 0x42, 0x4d, 0x4b, 0x42, 0x4b, 0x5d, 0xdd, 0xc4, 0xbc, + 0xb5, 0xae, 0xaf, 0xb6, 0xb7, 0xbc, 0xd3, 0xfe, 0x62, 0x4e, 0x4a, 0x4b, + 0x4d, 0x57, 0x5b, 0x5e, 0xe9, 0xd9, 0xd4, 0xc8, 0xbf, 0xbd, 0xbd, 0xbe, + 0xbf, 0xc8, 0xd8, 0xfe, 0x5d, 0x4f, 0x49, 0x45, 0x42, 0x3d, 0x34, 0x2e, + 0x2d, 0x2a, 0x27, 0x29, 0x2d, 0x2f, 0x3c, 0xce, 0xbd, 0xb9, 0xad, 0xad, + 0xb5, 0xb8, 0xc6, 0xe6, 0xe0, 0x54, 0x4d, 0xfb, 0x52, 0x48, 0x58, 0x4c, + 0x44, 0x4b, 0x54, 0xef, 0xc8, 0xbd, 0xb4, 0xae, 0xae, 0xb3, 0xb5, 0xbc, + 0xd7, 0x6b, 0x57, 0x48, 0x4c, 0x55, 0x4f, 0x6a, 0xe4, 0x6d, 0xe3, 0xd1, + 0xdb, 0xcd, 0xc3, 0xc4, 0xbf, 0xbd, 0xc3, 0xc9, 0xd5, 0x65, 0x51, 0x4a, + 0x3f, 0x3c, 0x39, 0x30, 0x2d, 0x2d, 0x29, 0x28, 0x2b, 0x2c, 0x2f, 0x49, + 0xcc, 0xc0, 0xb2, 0xaa, 0xad, 0xb2, 0xb7, 0xca, 0xde, 0x67, 0x49, 0x57, + 0x5d, 0x49, 0x55, 0x5b, 0x48, 0x4a, 0x4d, 0x52, 0xe6, 0xcd, 0xbf, 0xb3, + 0xaf, 0xb0, 0xb0, 0xb4, 0xbf, 0xd3, 0x72, 0x4e, 0x4b, 0x4f, 0x4e, 0x61, + 0xdb, 0xec, 0xe1, 0xd1, 0xe9, 0xe7, 0xd0, 0xd0, 0xc8, 0xc2, 0xc4, 0xc2, + 0xc8, 0xdf, 0x6d, 0x52, 0x41, 0x3b, 0x34, 0x2e, 0x2d, 0x2b, 0x29, 0x2a, + 0x2c, 0x2c, 0x33, 0x57, 0xd6, 0xc5, 0xaf, 0xac, 0xaf, 0xaf, 0xb7, 0xc6, + 0xcd, 0x5a, 0x48, 0x5b, 0x49, 0x44, 0x5b, 0x4f, 0x4a, 0x53, 0x4f, 0x5e, + 0xe4, 0xd8, 0xc1, 0xb6, 0xb4, 0xb3, 0xaf, 0xb5, 0xbf, 0xcc, 0xf6, 0x5b, + 0x56, 0x4c, 0x59, 0xdb, 0xdf, 0xdc, 0xc9, 0xce, 0xda, 0xd3, 0xd5, 0xcf, + 0xcc, 0xce, 0xc6, 0xc6, 0xdb, 0xf8, 0x61, 0x44, 0x38, 0x2f, 0x2d, 0x2b, + 0x29, 0x28, 0x2c, 0x2e, 0x2e, 0x3d, 0xdc, 0xdb, 0xc2, 0xaf, 0xb1, 0xb4, + 0xb3, 0xbf, 0xc3, 0xce, 0x4e, 0x5e, 0x64, 0x3f, 0x49, 0x58, 0x48, 0x4d, + 0x54, 0x5a, 0xdf, 0xd6, 0xcd, 0xba, 0xb5, 0xb7, 0xb3, 0xb2, 0xba, 0xc4, + 0xce, 0xdf, 0x76, 0x56, 0x54, 0xec, 0xe2, 0xfc, 0xd2, 0xcb, 0xd6, 0xd6, + 0xcf, 0xce, 0xcf, 0xd5, 0xce, 0xca, 0xda, 0x76, 0x68, 0x4c, 0x39, 0x30, + 0x2d, 0x2b, 0x28, 0x27, 0x2b, 0x2d, 0x2f, 0x3f, 0xe3, 0xd2, 0xbe, 0xb1, + 0xb2, 0xb4, 0xb6, 0xbf, 0xc2, 0xce, 0x5f, 0xf8, 0x70, 0x49, 0x50, 0x54, + 0x49, 0x4d, 0x4d, 0x55, 0xeb, 0xde, 0xce, 0xbb, 0xb7, 0xb7, 0xb4, 0xb4, + 0xba, 0xc3, 0xcd, 0xd2, 0xeb, 0x59, 0x68, 0xe2, 0xef, 0xf0, 0xd9, 0xd3, + 0xdb, 0xe2, 0xd9, 0xd2, 0xda, 0xda, 0xce, 0xcf, 0xe3, 0x70, 0x5a, 0x42, + 0x34, 0x2e, 0x2c, 0x29, 0x28, 0x29, 0x2c, 0x2e, 0x3b, 0x6a, 0xd6, 0xc1, + 0xb2, 0xb3, 0xb4, 0xb5, 0xbf, 0xc5, 0xcb, 0x65, 0x76, 0xf4, 0x4d, 0x58, + 0x5e, 0x4c, 0x51, 0x52, 0x4f, 0x6e, 0xe4, 0xd6, 0xc0, 0xba, 0xb9, 0xb5, + 0xb5, 0xba, 0xbf, 0xca, 0xd1, 0xe1, 0x64, 0x6b, 0xe1, 0xe2, 0xde, 0xcf, + 0xce, 0xd7, 0xda, 0xd9, 0xda, 0xdd, 0xdf, 0xd9, 0xd6, 0xe8, 0x66, 0x58, + 0x41, 0x34, 0x2f, 0x2d, 0x29, 0x29, 0x2b, 0x2c, 0x2f, 0x40, 0x6e, 0xdb, + 0xbd, 0xb2, 0xb6, 0xb5, 0xb6, 0xc2, 0xc3, 0xcf, 0x69, 0xe1, 0x6f, 0x4d, + 0x64, 0x59, 0x4a, 0x52, 0x4f, 0x52, 0x7a, 0xec, 0xcf, 0xbe, 0xbc, 0xb9, + 0xb5, 0xb7, 0xbc, 0xc2, 0xc9, 0xd1, 0xf2, 0x6b, 0xeb, 0xe2, 0xea, 0xdc, + 0xd1, 0xd5, 0xdd, 0xdb, 0xd9, 0xdf, 0xe1, 0xdb, 0xd7, 0xde, 0x74, 0x5f, + 0x4a, 0x38, 0x31, 0x2e, 0x2a, 0x29, 0x2a, 0x2b, 0x2e, 0x3a, 0x5d, 0xe0, + 0xc2, 0xb2, 0xb4, 0xb6, 0xb4, 0xbf, 0xc7, 0xc9, 0xfe, 0xed, 0xe3, 0x54, + 0x65, 0x6e, 0x4a, 0x4d, 0x4f, 0x4a, 0x56, 0x69, 0xdf, 0xc6, 0xbe, 0xba, + 0xb6, 0xb5, 0xb9, 0xbf, 0xc5, 0xcb, 0xde, 0xf7, 0xde, 0xd5, 0xd7, 0xd2, + 0xcb, 0xce, 0xd9, 0xdc, 0xdf, 0xeb, 0xf4, 0xef, 0xdf, 0xe2, 0x72, 0x5f, + 0x4b, 0x3a, 0x33, 0x2e, 0x2b, 0x29, 0x2a, 0x2b, 0x2e, 0x3d, 0x5e, 0xe7, + 0xc0, 0xb4, 0xb8, 0xb7, 0xb6, 0xc3, 0xc7, 0xcb, 0x7e, 0xdb, 0xe2, 0x56, + 0xf7, 0x6b, 0x49, 0x4f, 0x4d, 0x48, 0x52, 0x5b, 0xee, 0xca, 0xc2, 0xbc, + 0xb7, 0xb8, 0xbc, 0xbf, 0xc3, 0xcb, 0xda, 0xde, 0xd2, 0xd0, 0xd2, 0xcb, + 0xc9, 0xcf, 0xd9, 0xda, 0xdf, 0xef, 0x7e, 0xef, 0xe3, 0xfa, 0x5e, 0x54, + 0x42, 0x35, 0x2f, 0x2d, 0x2a, 0x29, 0x2b, 0x2c, 0x35, 0x4e, 0x69, 0xcd, + 0xb5, 0xb7, 0xba, 0xb5, 0xbe, 0xca, 0xc8, 0xe5, 0xe7, 0xd6, 0x5e, 0x73, + 0xde, 0x51, 0x4e, 0x57, 0x4a, 0x4b, 0x54, 0x63, 0xd7, 0xc7, 0xc1, 0xba, + 0xb7, 0xbb, 0xbe, 0xbf, 0xc6, 0xd3, 0xd8, 0xcf, 0xce, 0xd0, 0xcb, 0xc6, + 0xcb, 0xd7, 0xdb, 0xe0, 0x72, 0x5f, 0x67, 0x73, 0x64, 0x55, 0x4e, 0x43, + 0x37, 0x30, 0x2e, 0x2b, 0x2a, 0x2b, 0x2c, 0x35, 0x4d, 0x60, 0xcf, 0xb6, + 0xb8, 0xbb, 0xb5, 0xbe, 0xcc, 0xc9, 0xe5, 0xe2, 0xd3, 0x68, 0xee, 0xd6, + 0x5b, 0x54, 0x5b, 0x4c, 0x4c, 0x50, 0x5b, 0xdd, 0xcc, 0xc6, 0xbb, 0xb8, + 0xbb, 0xbe, 0xbe, 0xc3, 0xd0, 0xd6, 0xcc, 0xcc, 0xcf, 0xc8, 0xc4, 0xcb, + 0xd2, 0xd8, 0xe2, 0x7e, 0x5e, 0x5f, 0x6d, 0x5e, 0x50, 0x4b, 0x3f, 0x36, + 0x2f, 0x2d, 0x2b, 0x2a, 0x2a, 0x2d, 0x3b, 0x51, 0x65, 0xc3, 0xb4, 0xba, + 0xb9, 0xb6, 0xc2, 0xc7, 0xcb, 0xec, 0xd4, 0xd7, 0x67, 0xd9, 0xdb, 0x58, + 0x5c, 0x57, 0x4b, 0x4e, 0x4e, 0x5a, 0xdc, 0xd0, 0xca, 0xbd, 0xbb, 0xbe, + 0xc0, 0xbe, 0xc3, 0xd3, 0xce, 0xc4, 0xcc, 0xcd, 0xc2, 0xc5, 0xcd, 0xd1, + 0xdd, 0xe5, 0x6d, 0x57, 0x62, 0x62, 0x50, 0x4c, 0x45, 0x3b, 0x34, 0x2f, + 0x2d, 0x2b, 0x2a, 0x2b, 0x2f, 0x3f, 0x4e, 0x68, 0xbd, 0xb6, 0xbd, 0xb6, + 0xb7, 0xc4, 0xc1, 0xcd, 0xda, 0xc7, 0xdc, 0xe7, 0xc8, 0xe0, 0x62, 0x79, + 0x53, 0x4b, 0x4b, 0x48, 0x56, 0xfb, 0xea, 0xce, 0xbf, 0xbe, 0xc1, 0xbe, + 0xbc, 0xc4, 0xcd, 0xc2, 0xc1, 0xcb, 0xc4, 0xbf, 0xc5, 0xcb, 0xd3, 0xdd, + 0xeb, 0x57, 0x50, 0x5c, 0x51, 0x48, 0x44, 0x3f, 0x39, 0x32, 0x2f, 0x2d, + 0x2c, 0x2b, 0x2d, 0x35, 0x48, 0x4e, 0xe7, 0xb8, 0xba, 0xbd, 0xb3, 0xbb, + 0xc3, 0xbe, 0xd3, 0xcd, 0xc4, 0xe5, 0xd1, 0xc5, 0xed, 0x7a, 0xf5, 0x52, + 0x4d, 0x49, 0x48, 0x54, 0x60, 0x6c, 0xd7, 0xc7, 0xc6, 0xc9, 0xbf, 0xbe, + 0xca, 0xc7, 0xbe, 0xc3, 0xc3, 0xbe, 0xc2, 0xc3, 0xc8, 0xdc, 0xda, 0xee, + 0x52, 0x55, 0x56, 0x4a, 0x43, 0x3d, 0x39, 0x35, 0x2f, 0x2d, 0x2d, 0x2d, + 0x2c, 0x2f, 0x3f, 0x4e, 0x58, 0xc4, 0xb8, 0xbe, 0xb8, 0xb6, 0xc1, 0xbe, + 0xc5, 0xd7, 0xc3, 0xcd, 0xea, 0xc7, 0xce, 0x75, 0xea, 0x68, 0x4f, 0x4e, + 0x49, 0x4a, 0x59, 0x64, 0x70, 0xd7, 0xca, 0xcc, 0xc7, 0xbf, 0xc5, 0xc7, + 0xbf, 0xc0, 0xc3, 0xbd, 0xbf, 0xc3, 0xbf, 0xcb, 0xda, 0xd6, 0x7b, 0x59, + 0x59, 0x4e, 0x47, 0x40, 0x3b, 0x37, 0x32, 0x2f, 0x2d, 0x2d, 0x2d, 0x2d, + 0x34, 0x46, 0x4d, 0x79, 0xbd, 0xbc, 0xbe, 0xb5, 0xba, 0xc1, 0xbd, 0xc9, + 0xce, 0xc3, 0xd0, 0xd6, 0xc8, 0xd8, 0xfd, 0xf3, 0x59, 0x4b, 0x49, 0x48, + 0x48, 0x4f, 0x5f, 0x73, 0xdc, 0xcb, 0xca, 0xc6, 0xc0, 0xc5, 0xc2, 0xbe, + 0xc2, 0xbf, 0xbb, 0xc1, 0xc4, 0xc1, 0xcd, 0xdc, 0xe2, 0x72, 0x5a, 0x52, + 0x4b, 0x41, 0x3c, 0x39, 0x34, 0x30, 0x2f, 0x2e, 0x2e, 0x2f, 0x30, 0x3a, + 0x4c, 0x51, 0xde, 0xbc, 0xbf, 0xbf, 0xb6, 0xbc, 0xc3, 0xbe, 0xc6, 0xca, + 0xc5, 0xcc, 0xce, 0xcc, 0xd6, 0xea, 0x79, 0x5e, 0x4d, 0x49, 0x4c, 0x4b, + 0x4c, 0x63, 0xf8, 0xed, 0xcf, 0xc7, 0xc9, 0xc6, 0xbf, 0xbf, 0xc0, 0xbe, + 0xbb, 0xbd, 0xbf, 0xc0, 0xc6, 0xcd, 0xd7, 0xee, 0x6d, 0x5a, 0x4d, 0x47, + 0x3f, 0x3c, 0x38, 0x34, 0x31, 0x2f, 0x2f, 0x2e, 0x2f, 0x33, 0x3d, 0x4a, + 0x4f, 0xd8, 0xbe, 0xc4, 0xc0, 0xb9, 0xbe, 0xc6, 0xc1, 0xc3, 0xcb, 0xca, + 0xc8, 0xc9, 0xcd, 0xd2, 0xdd, 0x7e, 0x5e, 0x50, 0x4a, 0x4d, 0x4f, 0x4d, + 0x5b, 0xef, 0xee, 0xdb, 0xca, 0xc9, 0xcb, 0xc2, 0xbe, 0xc2, 0xbf, 0xbb, + 0xbd, 0xc1, 0xbf, 0xc3, 0xcf, 0xd8, 0xde, 0x69, 0x54, 0x52, 0x47, 0x3d, + 0x3c, 0x39, 0x35, 0x33, 0x33, 0x31, 0x2f, 0x32, 0x34, 0x3a, 0x47, 0x4f, + 0x7a, 0xca, 0xc4, 0xc6, 0xc0, 0xbd, 0xc4, 0xcc, 0xc4, 0xc3, 0xce, 0xcc, + 0xc4, 0xc7, 0xd2, 0xd4, 0xd3, 0xfb, 0x5c, 0x5a, 0x57, 0x57, 0x56, 0x5f, + 0xfd, 0xee, 0xdb, 0xd1, 0xd3, 0xcd, 0xc7, 0xc7, 0xc8, 0xc3, 0xbe, 0xc0, + 0xc4, 0xc1, 0xc3, 0xcd, 0xd6, 0xda, 0xf5, 0x5b, 0x53, 0x4e, 0x44, 0x3e, + 0x3d, 0x3b, 0x36, 0x34, 0x34, 0x33, 0x32, 0x34, 0x35, 0x3b, 0x46, 0x4d, + 0x5f, 0xd6, 0xca, 0xcb, 0xca, 0xc4, 0xc5, 0xcc, 0xcc, 0xc5, 0xc5, 0xc8, + 0xc6, 0xc2, 0xc6, 0xce, 0xd5, 0xdd, 0x7a, 0x63, 0x5d, 0x5a, 0x60, 0x65, + 0x6e, 0xf1, 0xdc, 0xd0, 0xd4, 0xd6, 0xcc, 0xc8, 0xcb, 0xca, 0xc2, 0xbf, + 0xc3, 0xc7, 0xc5, 0xc7, 0xd3, 0xe2, 0xf2, 0x6a, 0x5c, 0x4c, 0x47, 0x47, + 0x40, 0x3f, 0x3c, 0x39, 0x3c, 0x38, 0x36, 0x36, 0x37, 0x39, 0x3c, 0x47, + 0x4f, 0x62, 0xdd, 0xd3, 0xcf, 0xd0, 0xcc, 0xca, 0xd2, 0xd0, 0xca, 0xc6, + 0xc4, 0xc5, 0xc4, 0xc3, 0xc8, 0xd0, 0xd9, 0xe8, 0x73, 0x6e, 0x68, 0x66, + 0x77, 0xf2, 0xea, 0xe3, 0xde, 0xdc, 0xdc, 0xdb, 0xd6, 0xcf, 0xcd, 0xcb, + 0xc7, 0xc7, 0xc9, 0xcb, 0xd0, 0xd9, 0xe5, 0xf6, 0x6d, 0x63, 0x58, 0x4f, + 0x4d, 0x4b, 0x48, 0x42, 0x3f, 0x3f, 0x3c, 0x3b, 0x3b, 0x3b, 0x3b, 0x3a, + 0x3e, 0x47, 0x4d, 0x54, 0x67, 0xe5, 0xd9, 0xd8, 0xd9, 0xd5, 0xd1, 0xd2, + 0xcf, 0xcd, 0xca, 0xc7, 0xc4, 0xc4, 0xc9, 0xcb, 0xce, 0xd4, 0xdc, 0xeb, + 0xec, 0xe3, 0xe6, 0xe5, 0xe6, 0xe3, 0xde, 0xdd, 0xdc, 0xde, 0xdc, 0xd5, + 0xd4, 0xd2, 0xcf, 0xcf, 0xce, 0xd2, 0xda, 0xdd, 0xe6, 0xf7, 0x7d, 0x6f, + 0x69, 0x68, 0x5d, 0x59, 0x56, 0x4d, 0x4c, 0x4c, 0x4c, 0x4a, 0x44, 0x46, + 0x45, 0x43, 0x47, 0x42, 0x42, 0x45, 0x48, 0x52, 0x55, 0x5c, 0x6a, 0x72, + 0xef, 0xf5, 0xea, 0xe2, 0xe3, 0xdb, 0xd6, 0xcf, 0xcc, 0xcb, 0xca, 0xcc, + 0xcd, 0xd0, 0xd4, 0xd7, 0xda, 0xda, 0xd8, 0xd6, 0xd6, 0xd6, 0xd5, 0xd9, + 0xdd, 0xde, 0xde, 0xde, 0xdf, 0xdf, 0xdd, 0xdd, 0xde, 0xdf, 0xe6, 0xe9, + 0xf2, 0xfe, 0xf3, 0xfc, 0x70, 0x79, 0x7b, 0x6e, 0x67, 0x67, 0x65, 0x5c, + 0x58, 0x56, 0x57, 0x56, 0x54, 0x57, 0x52, 0x4f, 0x4e, 0x4b, 0x4a, 0x49, + 0x47, 0x48, 0x4c, 0x4f, 0x53, 0x5a, 0x5d, 0x60, 0x67, 0x65, 0x69, 0x6b, + 0x70, 0xf9, 0xeb, 0xdf, 0xda, 0xd5, 0xcf, 0xd0, 0xcf, 0xcf, 0xd3, 0xd2, + 0xd2, 0xd1, 0xcf, 0xd0, 0xd0, 0xd1, 0xd4, 0xd7, 0xdc, 0xde, 0xdf, 0xe2, + 0xe0, 0xdf, 0xdf, 0xe6, 0xe9, 0xe7, 0xec, 0xfc, 0x7b, 0x7c, 0x72, 0x6c, + 0x72, 0x7c, 0x75, 0x77, 0xfa, 0x73, 0x6f, 0x6c, 0x64, 0x68, 0x61, 0x62, + 0x64, 0x5c, 0x5f, 0x5e, 0x5b, 0x5d, 0x58, 0x57, 0x59, 0x54, 0x56, 0x56, + 0x53, 0x53, 0x53, 0x54, 0x57, 0x56, 0x59, 0x5f, 0x61, 0x63, 0x68, 0x6d, + 0x71, 0x7e, 0xfc, 0xf5, 0xe7, 0xe4, 0xe2, 0xda, 0xd9, 0xdb, 0xdb, 0xd9, + 0xd9, 0xda, 0xd9, 0xd8, 0xd7, 0xd7, 0xda, 0xda, 0xdc, 0xdf, 0xe3, 0xe9, + 0xea, 0xef, 0xf6, 0xef, 0xf5, 0x78, 0x79, 0xff, 0x73, 0x70, 0x73, 0x6f, + 0x70, 0x6f, 0x74, 0xfc, 0xff, 0xfb, 0xfd, 0x76, 0x79, 0x7b, 0x7a, 0x77, + 0x7c, 0x78, 0x6d, 0xf0, 0xf5, 0x64, 0x74, 0x76, 0x65, 0x6e, 0x6b, 0x6a, + 0x69, 0x5f, 0x69, 0x67, 0x5f, 0x65, 0x61, 0x61, 0x63, 0x5e, 0x5f, 0x60, + 0x5c, 0x5d, 0x5f, 0x61, 0x62, 0x61, 0x68, 0x77, 0x75, 0x6e, 0x7e, 0xfe, + 0x77, 0xf8, 0xf7, 0xf4, 0xeb, 0xec, 0xe8, 0xe3, 0xe6, 0xe1, 0xde, 0xe0, + 0xde, 0xdd, 0xdf, 0xdd, 0xdf, 0xe0, 0xde, 0xe7, 0xe5, 0xe5, 0xf6, 0xf3, + 0xf5, 0xfd, 0x7d, 0x7b, 0xfa, 0x7d, 0x7a, 0x76, 0x76, 0x78, 0x6d, 0xe2, + 0xe8, 0x55, 0x6a, 0xea, 0x61, 0x79, 0xf6, 0x6a, 0xfb, 0xfa, 0x79, 0xf5, + 0x7e, 0xfe, 0xf6, 0x75, 0x79, 0x7d, 0x79, 0xfe, 0x79, 0x71, 0x75, 0x79, + 0x6d, 0x6e, 0x75, 0x6e, 0x6f, 0x69, 0x6d, 0x79, 0x6b, 0x6b, 0x74, 0x70, + 0x6f, 0x6f, 0x6c, 0x70, 0x71, 0x71, 0x73, 0x6d, 0x6d, 0x64, 0xfa, 0xee, + 0x5a, 0x65, 0x6c, 0x64, 0x7d, 0x6f +}; + +static InputStream * +generateHelloWorld (void) +{ + return _alutInputStreamConstructFromMemory (helloWorldSample, + sizeof (helloWorldSample)); +} + +ALvoid * +alutLoadMemoryHelloWorld (ALenum *format, ALsizei *size, ALfloat *frequency) +{ + if (!_alutSanityCheck ()) + { + return NULL; + } + return _alutLoadMemoryFromInputStream (generateHelloWorld (), format, size, + frequency); +} + +ALuint +alutCreateBufferHelloWorld (void) +{ + if (!_alutSanityCheck ()) + { + return AL_NONE; + } + return _alutCreateBufferFromInputStream (generateHelloWorld ()); +}