Big code change, read description

1) Don't calculate big LUTs for mixer deltas on init (was just a waste of RAM) 2) The mixer now uses a 64-bit division to calculate max number of safe samples to mix (branchless), instead of using a big hackish LUT for DIV->MUL 3) Module and sample loaders have been refactored so that it's much simpler to write new loaders (or modify the old ones) 4) Added support for importing DIGI Booster (non-Pro) modules 5) Added support for importing 8-channel StarTrekker modules 6) Updated help text 7) Some more minor code change 8) Updated the Visual Studio project and make scripts to include the new loaders * Sorry for not making individual commits for all the changes, but at this point it was simply too difficult for me to do so!

Olav Sørensen committed 5 years ago

Commit 12f28da1 parent 2c1dbb237 files · +6956 −6838Browse files

Showing the changes to src (32 of 37 files). Show all

Unified · Split

32 files

src/ft2_audio.c +24 −22
src/ft2_audio.h +4 −4
src/ft2_diskop.c +52 −90
src/ft2_inst_ed.c +6 −12
src/ft2_inst_ed.h +2 −0
src/ft2_module_loader.c +248 −2315
src/ft2_module_loader.h +14 −2
src/ft2_replayer.c +46 −102
src/ft2_replayer.h +30 −30
src/ft2_sample_ed.c +45 −0
src/ft2_sample_ed.h +7 −0
src/ft2_sample_loader.c +125 −2071
src/ft2_sample_loader.h +22 −2
src/ft2_scopes.c +17 −18
src/ft2_scopes.h +6 −2
src/ft2_sysreqs.c +32 −1
src/ft2_sysreqs.h +18 −11
src/ft2_tables.c +8 −1
src/ft2_tables.h +3 −1
src/helpdata/FT2.HLP +13 −7
src/helpdata/ft2_help_data.h +2142 −2133
src/mixer/ft2_mix_macros.h +2 −11
src/modloaders/ft2_load_digi.c +260 −0
src/modloaders/ft2_load_mod.c +408 −0
src/modloaders/ft2_load_s3m.c +663 −0
src/modloaders/ft2_load_stk.c +350 −0
src/modloaders/ft2_load_stm.c +263 −0
src/modloaders/ft2_load_xm.c +626 −0
src/smploaders/ft2_load_aiff.c +510 −0
src/smploaders/ft2_load_iff.c +179 −0
src/smploaders/ft2_load_raw.c +30 −0
src/smploaders/ft2_load_wav.c +746 −0

src/ft2_audio.c+24−22

@@ -47,8 +47,8 @@ void resetCachedMixerVars(void) · 46 unmodified lines
47	voice_t *v = voice;	47	voice_t *v = voice;
48	for (int32_t i = 0; i < MAX_VOICES*2; i++, v++)	48	for (int32_t i = 0; i < MAX_VOICES*2; i++, v++)
49	{	49	{
		50	v->dOldHz = 0.0;
50	v->oldDelta = 0;	51	v->oldDelta = 0;
51	v->oldRevDelta = UINT32_MAX;
52	}	52	}
53	}	53	}
54		54
@@ -109,7 +109,6 @@ bool setNewAudioSettings(void) // only call this from the main input/video threa · 54 unmodified lines
109	return false;	109	return false;
110	}	110	}
111		111
112	calcRevMixDeltaTable();
113	resumeAudio();	112	resumeAudio();
114		113
115	setWavRenderFrequency(audio.freq);	114	setWavRenderFrequency(audio.freq);
@@ -140,10 +139,7 @@ void setNewAudioFreq(uint32_t freq) // for song-to-WAV rendering · 24 unmodified lines
140		139
141	const bool mustRecalcTables = audio.freq != oldAudioFreq;	140	const bool mustRecalcTables = audio.freq != oldAudioFreq;
142	if (mustRecalcTables)	141	if (mustRecalcTables)
143	{
144	calcReplayerVars(audio.freq);	142	calcReplayerVars(audio.freq);
145	calcRevMixDeltaTable();
146	}
147	}	143	}
148		144
149	void setBackOldAudioFreq(void) // for song-to-WAV rendering	145	void setBackOldAudioFreq(void) // for song-to-WAV rendering
@@ -153,10 +149,7 @@ void setBackOldAudioFreq(void) // for song-to-WAV rendering · 3 unmodified lines
153	audio.freq = oldAudioFreq;	149	audio.freq = oldAudioFreq;
154		150
155	if (mustRecalcTables)	151	if (mustRecalcTables)
156	{
157	calcReplayerVars(audio.freq);	152	calcReplayerVars(audio.freq);
158	calcRevMixDeltaTable();
159	}
160	}	153	}
161		154
162	void P_SetSpeed(uint16_t bpm)	155	void P_SetSpeed(uint16_t bpm)
@@ -383,26 +376,29 @@ void updateVoices(void) · 220 unmodified lines
383		376
384	if (status & IS_Period)	377	if (status & IS_Period)
385	{	378	{
386	// use cached values if possible	379	// use cached values when possible
387	if (ch->finalPeriod != ch->oldFinalPeriod)	380	if (ch->finalPeriod != ch->oldFinalPeriod)
388	{	381	{
389	ch->oldFinalPeriod = ch->finalPeriod;	382	ch->oldFinalPeriod = ch->finalPeriod;
390		383
391	if (ch->finalPeriod == 0) // in FT2, period 0 -> delta 0	384	if (ch->finalPeriod == 0) // in FT2, period 0 -> delta 0
392	{	385	{
		386	v->dOldHz = 0.0;
393	v->oldDelta = 0;	387	v->oldDelta = 0;
394	v->oldRevDelta = UINT32_MAX;
395	v->dSincLUT = gKaiserSinc;	388	v->dSincLUT = gKaiserSinc;
396	}	389	}
397	else	390	else
398	{	391	{
399	v->oldDelta = getMixerDelta(ch->finalPeriod);	392	const double dHz = dPeriod2Hz(ch->finalPeriod);
400	v->oldRevDelta = getRevMixerDelta(ch->finalPeriod); // for calc'ing max samples in inner mix loop before sample end/loop end	393	const uint64_t delta64 = (int64_t)((dHz * audio.dHz2MixDeltaMul) + 0.5); // Hz -> rounded 32.32 fixed-point
		394
		395	v->dOldHz = dHz;
		396	v->oldDelta = delta64;
401		397
402	// decide which sinc LUT to use according to resampling ratio	398	// decide which sinc LUT to use according to resampling ratio
403	if (v->oldDelta <= 0x130000000) // 1.1875 (32.32 fixed-point)	399	if (delta64 <= 0x130000000) // 1.1875 (32.32fp)
404	v->dSincLUT = gKaiserSinc;	400	v->dSincLUT = gKaiserSinc;
405	else if (v->oldDelta <= 0x180000000) // 1.5 (32.32 fixed-point)	401	else if (delta64 <= 0x180000000) // 1.5 (32.32fp)
406	v->dSincLUT = gDownSample1;	402	v->dSincLUT = gDownSample1;
407	else	403	else
408	v->dSincLUT = gDownSample2;	404	v->dSincLUT = gDownSample2;
@@ -410,7 +406,7 @@ void updateVoices(void) · 1 unmodified line
410	}	406	}
411		407
412	v->delta = v->oldDelta;	408	v->delta = v->oldDelta;
413	v->revDelta = v->oldRevDelta;	409	v->dHz = v->dOldHz;
414	}	410	}
415		411
416	if (status & IS_NyTon)	412	if (status & IS_NyTon)
@@ -878,18 +874,24 @@ static void fillVisualsSyncBuffer(void) · 461 unmodified lines
878		874
879	syncedChannel_t *c = chSyncData.channels;	875	syncedChannel_t *c = chSyncData.channels;
880	stmTyp *s = stm;	876	stmTyp *s = stm;
		877	voice_t *v = voice;
881		878
882	for (int32_t i = 0; i < song.antChn; i++, c++, s++)	879	for (int32_t i = 0; i < song.antChn; i++, c++, s++, v++)
883	{	880	{
884	c->finalPeriod = s->finalPeriod;	881	c->vol = s->finalVol;
885	c->fineTune = s->fineTune;	882	c->dHz = v->dHz;
886	c->relTonNr = s->relTonNr;
887	c->instrNr = s->instrNr;	883	c->instrNr = s->instrNr;
888	c->sampleNr = s->sampleNr;	884	c->sampleNr = s->sampleNr;
889	c->envSustainActive = s->envSustainActive;
890	c->status = s->tmpStatus;	885	c->status = s->tmpStatus;
891	c->dFinalVol = s->dFinalVol;	886	c->smpStartPos = (uint16_t)s->smpStartPos;
892	c->smpStartPos = s->smpStartPos;	887
		888	c->pianoNoteNr = 255; // no piano key
		889	if (songPlaying && (c->status & IS_Period) && s->envSustainActive)
		890	{
		891	const int32_t note = getPianoKey(s->finalPeriod, s->fineTune, s->relTonNr);
		892	if (note >= 0 && note <= 95)
		893	c->pianoNoteNr = (uint8_t)note;
		894	}
893	}	895	}
894		896
895	chSyncData.timestamp = audio.tickTime64;	897	chSyncData.timestamp = audio.tickTime64;

src/ft2_audio.h+4−4

@@ -34,7 +34,7 @@ typedef struct audio_t · 33 unmodified lines
34	uint32_t freq, audLatencyPerfValInt, audLatencyPerfValFrac, samplesPerTick, musicTimeSpeedVal;	34	uint32_t freq, audLatencyPerfValInt, audLatencyPerfValFrac, samplesPerTick, musicTimeSpeedVal;
35	uint64_t tickTime64, tickTime64Frac, tickTimeTab[MAX_BPM+1];	35	uint64_t tickTime64, tickTime64Frac, tickTimeTab[MAX_BPM+1];
36	double dRampQuickVolMul, dRampTickMul, dRampTickMulTab[MAX_BPM+1];	36	double dRampQuickVolMul, dRampTickMul, dRampTickMulTab[MAX_BPM+1];
37	double dMixBufferL, dMixBufferR, dMixBufferLUnaligned, dMixBufferRUnaligned;	37	double dMixBufferL, dMixBufferR, dMixBufferLUnaligned, dMixBufferRUnaligned, dHz2MixDeltaMul;
38	double dAudioLatencyMs, dSamplesPerTick, dTickSampleCounter, dSamplesPerTickTab[MAX_BPM+1];	38	double dAudioLatencyMs, dSamplesPerTick, dTickSampleCounter, dSamplesPerTickTab[MAX_BPM+1];
39		39
40	SDL_AudioDeviceID dev;	40	SDL_AudioDeviceID dev;
@@ -47,8 +47,8 @@ typedef struct · 6 unmodified lines
47	const int16_t base16, revBase16;	47	const int16_t base16, revBase16;
48	bool active, backwards, isFadeOutVoice, hasLooped;	48	bool active, backwards, isFadeOutVoice, hasLooped;
49	uint8_t mixFuncOffset, pan, loopType;	49	uint8_t mixFuncOffset, pan, loopType;
50	int32_t pos, end, loopStart, loopLength;	50	int32_t pos, end, loopStart, loopLength, oldPeriod;
51	uint32_t volRampSamples, revDelta, oldRevDelta;	51	uint32_t volRampSamples;
52	uint64_t posFrac, delta, oldDelta;	52	uint64_t posFrac, delta, oldDelta;
53		53
54	// if (loopEnabled && hasLooped && samplingPos <= loopStart+SINC_LEFT_TAPS) readFixedTapsFromThisPointer();	54	// if (loopEnabled && hasLooped && samplingPos <= loopStart+SINC_LEFT_TAPS) readFixedTapsFromThisPointer();
@@ -56,7 +56,7 @@ typedef struct · 1 unmodified line
56	const int16_t *leftEdgeTaps16;	56	const int16_t *leftEdgeTaps16;
57		57
58	const double *dSincLUT;	58	const double *dSincLUT;
59	double dVol, dDestVolL, dDestVolR, dVolL, dVolR, dVolDeltaL, dVolDeltaR;	59	double dOldHz, dHz, dVol, dDestVolL, dDestVolR, dVolL, dVolR, dVolDeltaL, dVolDeltaR;
60	} voice_t;	60	} voice_t;
61		61
62	typedef struct pattSyncData_t	62	typedef struct pattSyncData_t

src/ft2_diskop.c+52−90

@@ -1187,6 +1187,38 @@ void testDiskOpMouseRelease(void) · 1186 unmodified lines
1187	}	1187	}
1188	}	1188	}
1189		1189
		1190	static bool moduleExtensionAccepted(char *extPtr)
		1191	{
		1192	int32_t i = 0;
		1193	while (true)
		1194	{
		1195	const char *str = supportedModExtensions[i++];
		1196	if (!_stricmp(str, "END_OF_LIST"))
		1197	return false;
		1198
		1199	if (!_stricmp(str, extPtr))
		1200	break;
		1201	}
		1202
		1203	return true;
		1204	}
		1205
		1206	static bool sampleExtensionAccepted(char *extPtr)
		1207	{
		1208	int32_t i = 0;
		1209	while (true)
		1210	{
		1211	const char *str = supportedSmpExtensions[i++];
		1212	if (!_stricmp(str, "END_OF_LIST"))
		1213	return false;
		1214
		1215	if (!_stricmp(str, extPtr))
		1216	break;
		1217	}
		1218
		1219	return true;
		1220	}
		1221
1190	static uint8_t handleEntrySkip(UNICHAR *nameU, bool isDir)	1222	static uint8_t handleEntrySkip(UNICHAR *nameU, bool isDir)
1191	{	1223	{
1192	// skip if illegal name or filesize >32-bit	1224	// skip if illegal name or filesize >32-bit
@@ -1223,12 +1255,13 @@ static uint8_t handleEntrySkip(UNICHAR *nameU, bool isDir) · 30 unmodified lines
1223	}	1255	}
1224	else if (!FReq_ShowAllFiles)	1256	else if (!FReq_ShowAllFiles)
1225	{	1257	{
1226	const int32_t extOffset = getExtOffset(name, nameLen);	1258	int32_t extOffset = getExtOffset(name, nameLen);
1227	if (extOffset == -1)	1259	if (extOffset == -1)
1228	goto skipEntry;	1260	goto skipEntry;
		1261	extOffset++; // skip '.'
1229		1262
1230	const int32_t extLen = (int32_t)strlen(&name[extOffset]);	1263	const int32_t extLen = (int32_t)strlen(&name[extOffset]);
1231	if (extLen < 3 \|\| extLen > 5)	1264	if (extLen < 2 \|\| extLen > 6)
1232	goto skipEntry; // no possibly known extensions to filter out	1265	goto skipEntry; // no possibly known extensions to filter out
1233		1266
1234	char *extPtr = &name[extOffset];	1267	char *extPtr = &name[extOffset];
@@ -1239,117 +1272,46 @@ static uint8_t handleEntrySkip(UNICHAR *nameU, bool isDir) · 4 unmodified lines
1239	default:	1272	default:
1240	case DISKOP_ITEM_MODULE:	1273	case DISKOP_ITEM_MODULE:
1241	{	1274	{
1242	if (extLen == 3)	1275	if (editor.moduleSaveMode == MOD_SAVE_MODE_WAV && !_stricmp("wav", extPtr))
1243	{	1276	break; // show .wav files when save mode is "WAV"
1244	if (_stricmp(".xm", extPtr) && _stricmp(".ft", extPtr))	1277
1245	goto skipEntry; // skip, none of the extensions above	1278	if (!moduleExtensionAccepted(extPtr))
1246	}
1247	else if (extLen == 4)
1248	{
1249	if (editor.moduleSaveMode == MOD_SAVE_MODE_WAV)
1250	{
1251	if (_stricmp(".nst", extPtr) && _stricmp(".mod", extPtr) &&
1252	_stricmp(".s3m", extPtr) && _stricmp(".stm", extPtr) &&
1253	_stricmp(".fst", extPtr) && _stricmp(".wav", extPtr))
1254	{
1255	goto skipEntry; // skip, none of the extensions above
1256	}
1257	}
1258	else
1259	{
1260	if (_stricmp(".nst", extPtr) && _stricmp(".mod", extPtr) &&
1261	_stricmp(".s3m", extPtr) && _stricmp(".stm", extPtr) &&
1262	_stricmp(".fst", extPtr))
1263	{
1264	goto skipEntry; // skip, none of the extensions above
1265	}
1266	}
1267	}
1268	else
1269	{
1270	goto skipEntry;	1279	goto skipEntry;
1271	}
1272	}	1280	}
1273	break;	1281	break;
1274		1282
1275	case DISKOP_ITEM_INSTR:	1283	case DISKOP_ITEM_INSTR:
1276	{	1284	{
1277	if (extLen == 3)	1285	if (!_stricmp("xi", extPtr))
1278	{	1286	break;
1279	if (_stricmp(".xi", extPtr))	1287
1280	goto skipEntry; // skip, none of the extensions above	1288	if (!sampleExtensionAccepted(extPtr))
1281	}
1282	else if (extLen == 4)
1283	{
1284	if (_stricmp(".iff", extPtr) && _stricmp(".raw", extPtr) &&
1285	_stricmp(".wav", extPtr) && _stricmp(".snd", extPtr) &&
1286	_stricmp(".smp", extPtr) && _stricmp(".sam", extPtr) &&
1287	_stricmp(".aif", extPtr) && _stricmp(".pat", extPtr))
1288	{
1289	goto skipEntry; // skip, none of the extensions above
1290	}
1291	}
1292	else if (extLen == 5)
1293	{
1294	if (_stricmp(".aiff", extPtr))
1295	goto skipEntry; // skip, not the extension above
1296	}
1297	else
1298	{
1299	goto skipEntry;	1289	goto skipEntry;
1300	}
1301	}	1290	}
1302	break;	1291	break;
1303		1292
1304	case DISKOP_ITEM_SAMPLE:	1293	case DISKOP_ITEM_SAMPLE:
1305	{	1294	{
1306	if (extLen == 4)	1295	if (!sampleExtensionAccepted(extPtr))
1307	{
1308	if (_stricmp(".iff", extPtr) && _stricmp(".raw", extPtr) &&
1309	_stricmp(".wav", extPtr) && _stricmp(".snd", extPtr) &&
1310	_stricmp(".smp", extPtr) && _stricmp(".sam", extPtr) &&
1311	_stricmp(".aif", extPtr))
1312	{
1313	goto skipEntry; // skip, none of the extensions above
1314	}
1315	}
1316	else if (extLen == 5)
1317	{
1318	if (_stricmp(".aiff", extPtr))
1319	goto skipEntry; // skip, not the extension above
1320	}
1321	else
1322	{
1323	goto skipEntry;	1296	goto skipEntry;
1324	}
1325	}	1297	}
1326	break;	1298	break;
1327		1299
1328	case DISKOP_ITEM_PATTERN:	1300	case DISKOP_ITEM_PATTERN:
1329	{	1301	{
1330	if (extLen == 3)	1302	if (!_stricmp("xp", extPtr))
1331	{	1303	break;
1332	if (_stricmp(".xp", extPtr))	1304
1333	goto skipEntry; // skip, not the extension above	1305	goto skipEntry;
1334	}
1335	else
1336	{
1337	goto skipEntry;
1338	}
1339	}	1306	}
1340	break;	1307	break;
1341		1308
1342	case DISKOP_ITEM_TRACK:	1309	case DISKOP_ITEM_TRACK:
1343	{	1310	{
1344	if (extLen == 3)	1311	if (!_stricmp("xt", extPtr))
1345	{	1312	break;
1346	if (_stricmp(".xt", extPtr))	1313
1347	goto skipEntry; // skip, not the extension above	1314	goto skipEntry;
1348	}
1349	else
1350	{
1351	goto skipEntry;
1352	}
1353	}	1315	}
1354	break;	1316	break;
1355	}	1317	}

src/ft2_inst_ed.c+6−12

 #include "ft2_video.h"
 #include "ft2_sample_loader.h"
 #include "ft2_diskop.h"
-#include "ft2_module_loader.h"
 #include "ft2_tables.h"
 #include "ft2_bmp.h"
 #include "ft2_structs.h"
 			syncedChannel_t *c = chSyncData->channels;
 			for (int32_t i = 0; i < song.antChn; i++, c++)
 			{
-				if (c->instrNr == editor.curInstr && c->envSustainActive)
+				if (c->instrNr == editor.curInstr && c->pianoNoteNr <= 95)
-				{
+					newStatus[c->pianoNoteNr] = true;
-					const int32_t note = getPianoKey(c->finalPeriod, c->fineTune, c->relTonNr);
-					if (note >= 0 && note <= 95)
-						newStatus[note] = true;
-				}
 			}
 		}
 		else // song is not playing (jamming from keyboard/MIDI)
 loadDone:
 	fclose(f);
-	fixSampleName(editor.curInstr);
+	fixInstrAndSampleNames(editor.curInstr);
 	editor.updateCurInstr = true; // setMouseBusy(false) is called in the input/video thread when done
 	if (ih.antSamp > MAX_SMP_PER_INST)
 	(void)ptr;
 }
-static bool fileIsInstr(UNICHAR *filename)
+bool fileIsInstr(UNICHAR *filenameU)
 {
-	char header[22];
+	FILE *f = UNICHAR_FOPEN(filenameU, "rb");
-	FILE *f = UNICHAR_FOPEN(filename, "rb");
 	if (f == NULL)
 		return false;
+	char header[22];
 	fread(header, 1, sizeof (header), f);
 	fclose(f);

src/ft2_inst_ed.h+2−0

@@ -8,6 +8,8 @@ · 7 unmodified lines
8		8
9	void drawC4Rate(void);	9	void drawC4Rate(void);
10		10
		11	bool fileIsInstr(UNICHAR *filenameU);
		12
11	void saveInstr(UNICHAR *filenameU, int16_t nr);	13	void saveInstr(UNICHAR *filenameU, int16_t nr);
12	void loadInstr(UNICHAR *filenameU);	14	void loadInstr(UNICHAR *filenameU);
13	void copyInstr(void); // dstInstr = srcInstr	15	void copyInstr(void); // dstInstr = srcInstr

src/ft2_module_loader.c+248−2315

@@ -10,7 +10,6 @@ · 9 unmodified lines
10	#include <unistd.h>	10	#include <unistd.h>
11	#endif	11	#endif
12	#include "ft2_header.h"	12	#include "ft2_header.h"
13	#include "ft2_config.h"
14	#include "ft2_scopes.h"	13	#include "ft2_scopes.h"
15	#include "ft2_trim.h"	14	#include "ft2_trim.h"
16	#include "ft2_inst_ed.h"	15	#include "ft2_inst_ed.h"
@@ -24,1857 +23,206 @@ · 7 unmodified lines
24	#include "ft2_midi.h"	23	#include "ft2_midi.h"
25	#include "ft2_events.h"	24	#include "ft2_events.h"
26	#include "ft2_video.h"	25	#include "ft2_video.h"
27	#include "ft2_tables.h"
28	#include "ft2_structs.h"	26	#include "ft2_structs.h"
		27	#include "ft2_sysreqs.h"
29		28
30	/* This is a HUGE mess!	29	bool loadDIGI(FILE *f, uint32_t filesize);
31	** I hope you never have to modify it, and you probably shouldn't either.	30	bool loadMOD(FILE *f, uint32_t filesize);
32	** You will experience a lot of headaches if you dig into this file...	31	bool loadS3M(FILE *f, uint32_t filesize);
33	** If something looks to be wrong, it's probably right!	32	bool loadSTK(FILE *f, uint32_t filesize);
34	**	33	bool loadSTM(FILE *f, uint32_t filesize);
35	** The actual module load routines are ported from FT2 and slightly modified.	34	bool loadXM(FILE *f, uint32_t filesize);
36	*/
37		35
38	enum	36	enum
39	{	37	{
40	FORMAT_NONE = 0,	38	FORMAT_UNKNOWN = 0,
41	FORMAT_XM = 1,	39	FORMAT_POSSIBLY_STK = 1,
42	FORMAT_MOD = 2,	40	FORMAT_XM = 2,
43	FORMAT_S3M = 3,	41	FORMAT_MOD = 3,
44	FORMAT_STM = 4	42	FORMAT_S3M = 4,
		43	FORMAT_STM = 5,
		44	FORMAT_DIGI = 6
45	};	45	};
46		46
47	// .MOD types	47	// file extensions accepted by Disk Op. in module mode
48	enum	48	char *supportedModExtensions[] =
49	{
50	FORMAT_MK, // ProTracker or compatible
51	FORMAT_FLT, // StarTrekker (4-channel modules only)
52	FORMAT_FT2, // FT2 (or other trackers, multichannel)
53	FORMAT_STK, // The Ultimate SoundTracker (15 samples)
54	FORMAT_NT, // NoiseTracker
55	FORMAT_HMNT, // His Master's NoiseTracker (special one)
56
57	FORMAT_UNKNOWN // may be The Ultimate Soundtracker (set to FORMAT_STK later)
58	};
59
60	// DO NOT TOUCH THESE STRUCTS!
61
62	#ifdef _MSC_VER
63	#pragma pack(push)
64	#pragma pack(1)
65	#endif
66	typedef struct songSTMinstrHeaderTyp_t
67	{
68	char name[12];
69	uint8_t nul, insDisk;
70	uint16_t reserved1, len, repS, repE;
71	uint8_t vol, reserved2;
72	uint16_t rate;
73	int32_t reserved3;
74	uint16_t paraLen;
75	}
76	#ifdef __GNUC__
77	__attribute__ ((packed))
78	#endif
79	songSTMinstrHeaderTyp;
80
81	typedef struct songSTMHeaderTyp_t
82	{
83	char name[20], sig[8];
84	uint8_t id1a, typ;
85	uint8_t verMajor, verMinor;
86	uint8_t tempo, ap, vol, reserved[13];
87	songSTMinstrHeaderTyp instr[31];
88	uint8_t songTab[128];
89	}
90	#ifdef __GNUC__
91	__attribute__ ((packed))
92	#endif
93	songSTMHeaderTyp;
94
95	typedef struct songS3MinstrHeaderTyp_t
96	{
97	uint8_t typ;
98	char dosName[12];
99	uint8_t memSegH;
100	uint16_t memSeg;
101	int32_t len, repS, repE;
102	uint8_t vol, dsk, pack, flags;
103	int32_t c2Spd, res1;
104	uint16_t gusPos;
105	uint8_t res2[6];
106	char name[28], id[4];
107	}
108	#ifdef __GNUC__
109	__attribute__ ((packed))
110	#endif
111	songS3MinstrHeaderTyp;
112
113	typedef struct songS3MHeaderTyp_t
114	{
115	char name[28];
116	uint8_t id1a, typ;
117	uint16_t res1;
118	int16_t songTabLen, antInstr, antPatt;
119	uint16_t flags, trackerID, ver;
120	char id[4];
121	uint8_t globalVol, defSpeed, defTempo, masterVol, res2[12], chanType[32];
122	}
123	#ifdef __GNUC__
124	__attribute__ ((packed))
125	#endif
126	songS3MHeaderTyp;
127	#ifdef _MSC_VER
128	#pragma pack(pop)
129	#endif
130
131	static volatile uint8_t loadedFormat;
132	static volatile bool linearFreqTable, musicIsLoading, moduleLoaded, moduleFailedToLoad;
133	static uint8_t oldPlayMode, pattBuff[12288], packedPattData[65536];
134	static const uint8_t stmEff[16] = { 0, 0, 11, 0, 10, 2, 1, 3, 4, 7, 0, 5 ,6, 0, 0, 0 };
135	static SDL_Thread *thread;
136
137	// these temporarily read to, then copied to real struct if load was OK (should not need to be volatile'd)
138	static int16_t pattLensTmp[MAX_PATTERNS];
139	static uint32_t extraSampleLengths[32-MAX_SMP_PER_INST]; // ModPlug Tracker & OpenMPT supports up to 32 samples per instrument in .XM
140	static tonTyp *pattTmp[MAX_PATTERNS];
141	static instrTyp *instrTmp[1+256];
142	static songTyp songTmp;
143
144	static void setupLoadedModule(void);
145	static void freeTmpModule(void);
146	static bool loadInstrHeader(FILE *f, uint16_t i, bool externalThreadFlag);
147	static bool loadInstrSample(FILE *f, uint16_t i, bool externalThreadFlag);
148	void unpackPatt(uint8_t dst, uint8_t src, uint16_t len, int32_t antChn);
149	static bool tmpPatternEmpty(uint16_t nr);
150	static bool loadPatterns(FILE *f, uint16_t antPtn, bool externalThreadFlag);
151
152	void checkSampleRepeat(sampleTyp *s);
153
154	// ft2_replayer.c
155	extern const char modSig[32][5];
156
157	static bool allocateTmpInstr(int16_t nr)
158	{
159	if (instrTmp[nr] != NULL)
160	return false; // already allocated
161
162	instrTyp p = (instrTyp )calloc(1, sizeof (instrTyp));
163	if (p == NULL)
164	return false;
165
166	sampleTyp *s = p->samp;
167	for (int32_t i = 0; i < MAX_SMP_PER_INST; i++, s++)
168	{
169	s->pan = 128;
170	s->vol = 64;
171	}
172
173	instrTmp[nr] = p;
174	return true;
175	}
176
177	#define IS_ID(s, b) !strncmp(s, b, 4)
178
179	static uint8_t getModType(uint8_t numChannels, const char id)
180	{
181	uint8_t modFormat = FORMAT_UNKNOWN;
182	*numChannels = 4;
183
184	if (IS_ID("M.K.", id) \|\| IS_ID("M!K!", id) \|\| IS_ID("NSMS", id) \|\| IS_ID("LARD", id) \|\| IS_ID("PATT", id))
185	{
186	modFormat = FORMAT_MK; // ProTracker or compatible
187	}
188	else if (id[1] == 'C' && id[2] == 'H' && id[3] == 'N')
189	{
190	modFormat = FORMAT_FT2; // FT2 or generic multichannel
191	*numChannels = id[0] - '0';
192	}
193	else if (id[2] == 'C' && (id[3] == 'H' \|\| id[3] == 'N'))
194	{
195	modFormat = FORMAT_FT2; // FT2 or generic multichannel
196	numChannels = ((id[0] - '0') 10) + (id[1] - '0');
197	}
198	else if (IS_ID("FLT4", id))
199	{
200	modFormat = FORMAT_FLT; // StarTrekker (4-channel modules only)
201	}
202	else if (IS_ID("N.T.", id))
203	{
204	modFormat = FORMAT_NT; // NoiseTracker
205	}
206	else if (IS_ID("M&K!", id) \|\| IS_ID("FEST", id))
207	{
208	modFormat = FORMAT_HMNT; // His Master's NoiseTracker
209	}
210
211	return modFormat;
212	}
213
214	static bool loadMusicMOD(FILE *f, uint32_t fileLength, bool externalThreadFlag)
215	{
216	char ID[16];
217	uint8_t bytes[4], modFormat, numChannels;
218	int16_t i, j, k, ai;
219	uint16_t a, b, period;
220	tonTyp *ton;
221	sampleTyp *s;
222	songMOD31HeaderTyp h_MOD31;
223	songMOD15HeaderTyp h_MOD15;
224	int16_t (showMsg)(int16_t, const char , const char *);
225
226	showMsg = externalThreadFlag ? okBoxThreadSafe : okBox;
227
228	bool veryLateSTKVerFlag = false; // "DFJ SoundTracker III" nad later
229	bool lateSTKVerFlag = false; // "TJC SoundTracker II" and later
230	bool mightBeSTK = false;
231
232	memset(&songTmp, 0, sizeof (songTmp));
233	memset(&h_MOD31, 0, sizeof (songMOD31HeaderTyp));
234	memset(&h_MOD15, 0, sizeof (songMOD15HeaderTyp));
235
236	// start loading MOD
237
238	loadedFormat = FORMAT_MOD;
239
240	rewind(f);
241	fread(ID, 1, 16, f);
242	fseek(f, 0x1D, SEEK_SET);
243	fread(bytes, 1, 1, f);
244	rewind(f);
245
246	// since .mod is the last format tested, check if the file is an .it module (Impulse Tracker)
247	if (!memcmp(ID, "IMPM", 4) && bytes[0] == 0)
248	{
249	showMsg(0, "System message", "Error: Impulse Tracker modules are not supported!");
250	goto modLoadError;
251	}
252
253	// check if the file to load is a WAV, if so reject it
254	if (!memcmp(ID, "RIFF", 4) && !memcmp(&ID[8], "WAVEfmt", 7))
255	{
256	showMsg(0, "System message", "Error: Can't load a .wav file as a module!");
257	goto modLoadError;
258	}
259
260	if (fileLength < 1596 \|\| fileLength > 20842494) // minimum and maximum possible size for a supported .mod
261	{
262	showMsg(0, "System message", "Error: This file is either not a module, or is not supported.");
263	goto modLoadError;
264	}
265
266	if (fread(&h_MOD31, 1, sizeof (h_MOD31), f) != sizeof (h_MOD31))
267	{
268	showMsg(0, "System message", "Error: This file is either not a module, or is not supported.");
269	goto modLoadError;
270	}
271
272	modFormat = getModType(&numChannels, h_MOD31.sig);
273
274	if (modFormat == FORMAT_FLT && numChannels == 8)
275	{
276	showMsg(0, "System message", "8-channel Startrekker modules are not supported!");
277	goto modLoadError;
278	}
279
280	if (modFormat != FORMAT_UNKNOWN)
281	{
282	if (fileLength < sizeof (h_MOD31))
283	{
284	showMsg(0, "System message", "Error: This file is either not a module, or is not supported.");
285	goto modLoadError;
286	}
287
288	songTmp.antChn = numChannels;
289	songTmp.len = h_MOD31.len;
290	songTmp.repS = h_MOD31.repS;
291	memcpy(songTmp.songTab, h_MOD31.songTab, 128);
292	ai = 31;
293	}
294	else
295	{
296	mightBeSTK = true;
297	if (fileLength < sizeof (h_MOD15))
298	{
299	showMsg(0, "System message", "Error: This file is not a module!");
300	goto modLoadError;
301	}
302
303	rewind(f);
304	if (fread(&h_MOD15, 1, sizeof (h_MOD15), f) != sizeof (h_MOD15))
305	{
306	showMsg(0, "System message", "Error: This file is either not a module, or is not supported.");
307	goto modLoadError;
308	}
309
310	songTmp.antChn = numChannels;
311	songTmp.len = h_MOD15.len;
312	songTmp.repS = h_MOD15.repS;
313	memcpy(songTmp.songTab, h_MOD15.songTab, 128);
314	ai = 15;
315	}
316
317	if (modFormat == FORMAT_MK && songTmp.len == 129)
318	songTmp.len = 127; // fixes a specific copy of beatwave.mod (FIXME: Do we want to keep this digsuting hack?)
319
320	if (songTmp.antChn == 0 \|\| songTmp.len < 1 \|\| songTmp.len > 128 \|\| (mightBeSTK && songTmp.repS > 220))
321	{
322	showMsg(0, "System message", "Error: This file is either not a module, or is not supported.");
323	goto modLoadError;
324	}
325
326	for (a = 0; a < ai; a++)
327	{
328	songMODInstrHeaderTyp *smp = &h_MOD31.instr[a];
329
330	if (modFormat != FORMAT_HMNT) // most of "His Master's Noisetracker" songs have junk sample names, so let's not load them
331	{
332	// trim off spaces at end of name
333	for (i = 21; i >= 0; i--)
334	{
335	if (smp->name[i] == ' ' \|\| smp->name[i] == 0x1A)
336	smp->name[i] = '\0';
337	else
338	break;
339	}
340
341	memcpy(songTmp.instrName[1+a], smp->name, 22);
342	songTmp.instrName[1+a][22] = '\0';
343	}
344
345	/* Only late versions of Ultimate SoundTracker could have samples larger than 9999 bytes.
346	** If found, we know for sure that this is a late STK module.
347	*/
348	if (mightBeSTK && 2*SWAP16(smp->len) > 9999)
349	lateSTKVerFlag = true;
350	}
351
352	songTmp.speed = 125;
353	if (mightBeSTK)
354	{
355	/* If we're still here at this point and the mightBeSTK flag is set,
356	** then it's most likely a proper The Ultimate SoundTracker (STK/UST) module.
357	*/
358	modFormat = FORMAT_STK;
359
360	if (songTmp.repS == 0)
361	songTmp.repS = 120;
362
363	// jjk55.mod by Jesper Kyd has a bogus STK tempo value that should be ignored (hackish!)
364	if (!strcmp("jjk55", h_MOD31.name))
365	songTmp.repS = 120;
366
367	// The "restart pos" field in STK is the inital tempo (must be converted to BPM first)
368	if (songTmp.repS != 120) // 120 is a special case and means 50Hz (125BPM)
369	{
370	if (songTmp.repS > 220)
371	songTmp.repS = 220;
372
373	// convert UST tempo to BPM
374	uint16_t ciaPeriod = (240 - songTmp.repS) * 122;
375	double dHz = 709379.0 / ciaPeriod;
376	int32_t BPM = (int32_t)((dHz * 2.5) + 0.5);
377
378	songTmp.speed = (uint16_t)BPM;
379	}
380
381	songTmp.repS = 0;
382	}
383	else if (songTmp.repS >= songTmp.len)
384	{
385	songTmp.repS = 0;
386	}
387
388	// trim off spaces at end of name
389	for (i = 19; i >= 0; i--)
390	{
391	if (h_MOD31.name[i] == ' ' \|\| h_MOD31.name[i] == 0x1A)
392	h_MOD31.name[i] = '\0';
393	else
394	break;
395	}
396
397	memcpy(songTmp.name, h_MOD31.name, 20);
398	songTmp.name[20] = '\0';
399
400	// count number of patterns
401	b = 0;
402	for (a = 0; a < 128; a++)
403	{
404	if (songTmp.songTab[a] > b)
405	b = songTmp.songTab[a];
406	}
407	b++;
408
409	for (a = 0; a < b; a++)
410	{
411	pattTmp[a] = (tonTyp )calloc((MAX_PATT_LEN TRACK_WIDTH) + 16, 1);
412	if (pattTmp[a] == NULL)
413	{
414	showMsg(0, "System message", "Not enough memory!");
415	goto modLoadError;
416	}
417
418	pattLensTmp[a] = 64;
419	for (j = 0; j < 64; j++)
420	{
421	for (k = 0; k < songTmp.antChn; k++)
422	{
423	ton = &pattTmp[a][(j * MAX_VOICES) + k];
424
425	if (fread(bytes, 1, 4, f) != 4)
426	{
427	showMsg(0, "System message", "Error: This file is either not a module, or is not supported.");
428	goto modLoadError;
429	}
430
431	// period to note
432	period = ((bytes[0] & 0x0F) << 8) \| bytes[1];
433	for (i = 0; i < 8*12; i++)
434	{
435	if (period >= amigaPeriod[i])
436	{
437	ton->ton = (uint8_t)i + 1;
438	break;
439	}
440	}
441
442	ton->instr = (bytes[0] & 0xF0) \| (bytes[2] >> 4);
443	ton->effTyp = bytes[2] & 0x0F;
444	ton->eff = bytes[3];
445
446	if (modFormat == FORMAT_STK)
447	{
448	if (ton->effTyp == 0xC \|\| ton->effTyp == 0xD \|\| ton->effTyp == 0xE)
449	{
450	// "TJC SoundTracker II" and later
451	lateSTKVerFlag = true;
452	}
453
454	if (ton->effTyp == 0xF)
455	{
456	// "DFJ SoundTracker III" and later
457	lateSTKVerFlag = true;
458	veryLateSTKVerFlag = true;
459	}
460	}
461
462	if (ton->effTyp == 0xC)
463	{
464	if (ton->eff > 64)
465	ton->eff = 64;
466	}
467	else if (ton->effTyp == 0x1)
468	{
469	if (ton->eff == 0)
470	ton->effTyp = 0;
471	}
472	else if (ton->effTyp == 0x2)
473	{
474	if (ton->eff == 0)
475	ton->effTyp = 0;
476	}
477	else if (ton->effTyp == 0x5)
478	{
479	if (ton->eff == 0)
480	ton->effTyp = 0x3;
481	}
482	else if (ton->effTyp == 0x6)
483	{
484	if (ton->eff == 0)
485	ton->effTyp = 0x4;
486	}
487	else if (ton->effTyp == 0xA)
488	{
489	if (ton->eff == 0)
490	ton->effTyp = 0;
491	}
492	else if (ton->effTyp == 0xE)
493	{
494	// check if certain E commands are empty
495	if (ton->eff == 0x10 \|\| ton->eff == 0x20 \|\| ton->eff == 0xA0 \|\| ton->eff == 0xB0)
496	{
497	ton->effTyp = 0;
498	ton->eff = 0;
499	}
500	}
501	}
502	}
503
504	if (tmpPatternEmpty(a))
505	{
506	if (pattTmp[a] != NULL)
507	{
508	free(pattTmp[a]);
509	pattTmp[a] = NULL;
510	}
511	}
512	}
513
514	// pattern command conversion for non-PT formats
515	if (modFormat == FORMAT_STK \|\| modFormat == FORMAT_NT \|\| modFormat == FORMAT_HMNT \|\| modFormat == FORMAT_FLT)
516	{
517	for (a = 0; a < b; a++)
518	{
519	if (pattTmp[a] == NULL)
520	continue;
521
522	for (j = 0; j < 64; j++)
523	{
524	for (k = 0; k < songTmp.antChn; k++)
525	{
526	ton = &pattTmp[a][(j * MAX_VOICES) + k];
527
528	if (modFormat == FORMAT_NT \|\| modFormat == FORMAT_HMNT)
529	{
530	// any Dxx == D00 in NT/HMNT
531	if (ton->effTyp == 0xD)
532	ton->eff = 0;
533
534	// effect F with param 0x00 does nothing in NT/HMNT
535	if (ton->effTyp == 0xF && ton->eff == 0)
536	ton->effTyp = 0;
537	}
538	else if (modFormat == FORMAT_FLT) // Startrekker
539	{
540	if (ton->effTyp == 0xE) // remove unsupported "assembly macros" command
541	{
542	ton->effTyp = 0;
543	ton->eff = 0;
544	}
545
546	// Startrekker is always in vblank mode, and limits speed to 0x1F
547	if (ton->effTyp == 0xF && ton->eff > 0x1F)
548	ton->eff = 0x1F;
549	}
550	else if (modFormat == FORMAT_STK)
551	{
552	// convert STK effects to PT effects
553
554	if (!lateSTKVerFlag)
555	{
556	// old SoundTracker 1.x commands
557
558	if (ton->effTyp == 1)
559	{
560	// arpeggio
561	ton->effTyp = 0;
562	}
563	else if (ton->effTyp == 2)
564	{
565	// pitch slide
566	if (ton->eff & 0xF0)
567	{
568	// pitch slide down
569	ton->effTyp = 2;
570	ton->eff >>= 4;
571	}
572	else if (ton->eff & 0x0F)
573	{
574	// pitch slide up
575	ton->effTyp = 1;
576	}
577	}
578	}
579	else
580	{
581	// "DFJ SoundTracker II" or later
582
583	if (ton->effTyp == 0xD)
584	{
585	if (veryLateSTKVerFlag) // "DFJ SoundTracker III" or later
586	{
587	// pattern break w/ no param (param must be cleared to fix some songs)
588	ton->eff = 0;
589	}
590	else
591	{
592	// volume slide
593	ton->effTyp = 0xA;
594	}
595	}
596	}
597
598	// effect F with param 0x00 does nothing in UST/STK (I think?)
599	if (ton->effTyp == 0xF && ton->eff == 0)
600	ton->effTyp = 0;
601	}
602	}
603	}
604	}
605	}
606
607	for (a = 0; a < ai; a++)
608	{
609	if (h_MOD31.instr[a].len == 0)
610	continue;
611
612	if (!allocateTmpInstr(1+a))
613	{
614	showMsg(0, "System message", "Not enough memory!");
615	goto modLoadError;
616	}
617
618	setNoEnvelope(instrTmp[1+a]);
619
620	s = &instrTmp[1+a]->samp[0];
621
622	s->len = 2 * SWAP16(h_MOD31.instr[a].len);
623
624	if (modFormat != FORMAT_HMNT) // most of "His Master's Noisetracker" songs have junk sample names, so let's not load them
625	memcpy(s->name, songTmp.instrName[1+a], 22);
626
627	if (modFormat == FORMAT_HMNT) // finetune in "His Master's NoiseTracker" is different
628	h_MOD31.instr[a].fine = (uint8_t)((-h_MOD31.instr[a].fine & 0x1F) >> 1); // one more bit of precision, + inverted
629
630	if (modFormat != FORMAT_STK)
631	s->fine = 8 * ((2 * ((h_MOD31.instr[a].fine & 0xF) ^ 8)) - 16);
632
633	s->pan = 128;
634
635	s->vol = h_MOD31.instr[a].vol;
636	if (s->vol > 64)
637	s->vol = 64;
638
639	s->repS = 2 * SWAP16(h_MOD31.instr[a].repS);
640	s->repL = 2 * SWAP16(h_MOD31.instr[a].repL);
641
642	if (s->repL < 2)
643	s->repL = 2;
644
645	// in The Ultimate SoundTracker, sample loop start is in bytes, not words
646	if (modFormat == FORMAT_STK)
647	s->repS >>= 1;
648
649	// fix for poorly converted STK (< v2.5) -> PT/NT modules (FIXME: Worth keeping or not?)
650	if (modFormat != FORMAT_STK && s->repL > 2 && s->repS+s->repL > s->len)
651	{
652	if ((s->repS>>1)+s->repL <= s->len)
653	s->repS >>= 1;
654	}
655
656	// fix overflown loop
657	if (s->repS+s->repL > s->len)
658	{
659	if (s->repS >= s->len)
660	{
661	s->repS = 0;
662	s->repL = 0;
663	}
664	else
665	{
666	s->repL = s->len - s->repS;
667	}
668	}
669
670	if (s->repS+s->repL > 2)
671	s->typ = 1; // enable loop
672
673	/* For Ultimate SoundTracker modules, only the loop area of a looped sample is played.
674	** Skip loading of eventual data present before loop start.
675	*/
676	if (modFormat == FORMAT_STK && s->repS > 0 && s->repL < s->len)
677	{
678	s->len -= s->repS;
679	fseek(f, s->repS, SEEK_CUR);
680	s->repS = 0;
681	}
682
683	s->pek = NULL;
684	s->origPek = (int8_t *)malloc(s->len + LOOP_FIX_LEN);
685	if (s->origPek == NULL)
686	{
687	showMsg(0, "System message", "Not enough memory!");
688	goto modLoadError;
689	}
690
691	s->pek = s->origPek + SMP_DAT_OFFSET;
692
693	int32_t bytesRead = (int32_t)fread(s->pek, 1, s->len, f);
694	if (bytesRead < s->len)
695	{
696	int32_t bytesToClear = s->len - bytesRead;
697	memset(&s->pek[bytesRead], 0, bytesToClear);
698	}
699
700	// clear repL and repS on non-looping samples...
701	if (s->typ == 0)
702	{
703	s->repL = 0;
704	s->repS = 0;
705	}
706
707	fixSample(s);
708	}
709
710	fclose(f);
711
712	songTmp.initialTempo = songTmp.tempo = 6;
713
714	moduleLoaded = true;
715	return true;
716
717	modLoadError:
718	fclose(f);
719	freeTmpModule();
720	moduleFailedToLoad = true;
721	return false;
722	}
723
724	static uint8_t stmTempoToBPM(uint8_t tempo) // ported from original ST2.3 replayer code
725	{
726	const uint8_t slowdowns[16] = { 140, 50, 25, 15, 10, 7, 6, 4, 3, 3, 2, 2, 2, 2, 1, 1 };
727	uint16_t hz = 50;
728
729	hz -= ((slowdowns[tempo >> 4] * (tempo & 15)) >> 4); // can and will underflow
730
731	const uint32_t bpm = (hz << 1) + (hz >> 1); // BPM = hz * 2.5
732	return (uint8_t)CLAMP(bpm, 32, 255); // result can be slightly off, but close enough...
733	}
734
735	static bool loadMusicSTM(FILE *f, uint32_t fileLength, bool externalThreadFlag)
736	{
737	uint8_t typ, tempo;
738	int16_t i, j, k, ap, tmp;
739	uint16_t a;
740	tonTyp *ton;
741	sampleTyp *s;
742	songSTMHeaderTyp h_STM;
743	int16_t (showMsg)(int16_t, const char , const char *);
744
745	showMsg = externalThreadFlag ? okBoxThreadSafe : okBox;
746
747	rewind(f);
748
749	// start loading STM
750
751	if (fread(&h_STM, 1, sizeof (h_STM), f) != sizeof (h_STM))
752	return loadMusicMOD(f, fileLength, externalThreadFlag); // file is not a .stm, try to load as .mod
753
754	if (memcmp(h_STM.sig, "!Scream!", 8) && memcmp(h_STM.sig, "BMOD2STM", 8) &&
755	memcmp(h_STM.sig, "WUZAMOD!", 8) && memcmp(h_STM.sig, "SWavePro", 8))
756	{
757	return loadMusicMOD(f, fileLength, externalThreadFlag); // file is not a .stm, try to load as .mod
758	}
759
760	loadedFormat = FORMAT_STM;
761
762	if (h_STM.verMinor == 0 \|\| h_STM.typ != 2)
763	{
764	showMsg(0, "System message", "Error loading .stm: Incompatible module!");
765	goto stmLoadError;
766	}
767
768	songTmp.antChn = 4;
769	memcpy(songTmp.songTab, h_STM.songTab, 128);
770
771	i = 0;
772	while (i < 128 && songTmp.songTab[i] < 99) i++;
773	songTmp.len = i + (i == 0);
774
775	if (songTmp.len < 255)
776	memset(&songTmp.songTab[songTmp.len], 0, 256 - songTmp.len);
777
778	// trim off spaces at end of name
779	for (i = 19; i >= 0; i--)
780	{
781	if (h_STM.name[i] == ' ' \|\| h_STM.name[i] == 0x1A)
782	h_STM.name[i] = '\0';
783	else
784	break;
785	}
786
787	memcpy(songTmp.name, h_STM.name, 20);
788	songTmp.name[20] = '\0';
789
790	tempo = h_STM.tempo;
791	if (h_STM.verMinor < 21)
792	tempo = ((tempo / 10) << 4) + (tempo % 10);
793
794	if (tempo == 0)
795	tempo = 96;
796
797	songTmp.initialTempo = songTmp.tempo = CLAMP(h_STM.tempo >> 4, 1, 31);
798	songTmp.speed = stmTempoToBPM(tempo);
799
800	if (h_STM.verMinor > 10)
801	songTmp.globVol = MIN(h_STM.vol, 64);
802
803	ap = h_STM.ap;
804	for (i = 0; i < ap; i++)
805	{
806	pattTmp[i] = (tonTyp )calloc((MAX_PATT_LEN TRACK_WIDTH) + 16, 1);
807	if (pattTmp[i] == NULL)
808	{
809	showMsg(0, "System message", "Not enough memory!");
810	goto stmLoadError;
811	}
812
813	pattLensTmp[i] = 64;
814	if (fread(pattBuff, 64 * 4 * 4, 1, f) != 1)
815	{
816	showMsg(0, "System message", "General I/O error during loading!");
817	goto stmLoadError;
818	}
819
820	a = 0;
821	for (j = 0; j < 64; j++)
822	{
823	for (k = 0; k < 4; k++)
824	{
825	ton = &pattTmp[i][(j * MAX_VOICES) + k];
826
827	if (pattBuff[a] == 254)
828	{
829	ton->ton = 97;
830	}
831	else if (pattBuff[a] < 96)
832	{
833	ton->ton = (12 * (pattBuff[a] >> 4)) + (25 + (pattBuff[a] & 0x0F));
834	if (ton->ton > 96)
835	ton->ton = 0;
836	}
837	else
838	{
839	ton->ton = 0;
840	}
841
842	ton->instr = pattBuff[a + 1] >> 3;
843	typ = (pattBuff[a + 1] & 7) + ((pattBuff[a + 2] & 0xF0) >> 1);
844	if (typ <= 64)
845	ton->vol = typ + 0x10;
846
847	ton->eff = pattBuff[a + 3];
848
849	tmp = pattBuff[a + 2] & 0x0F;
850	if (tmp == 1)
851	{
852	ton->effTyp = 15;
853
854	if (h_STM.verMinor < 21)
855	ton->eff = ((ton->eff / 10) << 4) + (ton->eff % 10);
856
857	ton->eff >>= 4;
858	}
859	else if (tmp == 3)
860	{
861	ton->effTyp = 13;
862	ton->eff = 0;
863	}
864	else if (tmp == 2 \|\| (tmp >= 4 && tmp <= 12))
865	{
866	ton->effTyp = stmEff[tmp];
867	if (ton->effTyp == 0xA)
868	{
869	if (ton->eff & 0x0F)
870	ton->eff &= 0x0F;
871	else
872	ton->eff &= 0xF0;
873	}
874	}
875	else
876	{
877	ton->eff = 0;
878	}
879
880	if (ton->effTyp > 35)
881	{
882	ton->effTyp = 0;
883	ton->eff = 0;
884	}
885
886	a += 4;
887	}
888	}
889
890	if (tmpPatternEmpty(i))
891	{
892	if (pattTmp[i] != NULL)
893	{
894	free(pattTmp[i]);
895	pattTmp[i] = NULL;
896	}
897	}
898	}
899
900	for (i = 0; i < 31; i++)
901	{
902	// trim off spaces at end of name
903	for (j = 11; j >= 0; j--)
904	{
905	if (h_STM.instr[i].name[j] == ' ' \|\| h_STM.instr[i].name[j] == 0x1A)
906	h_STM.instr[i].name[j] = '\0';
907	else
908	break;
909	}
910
911	memset(&songTmp.instrName[1+i], 0, sizeof (songTmp.instrName[1+i]));
912	memcpy(&songTmp.instrName[1+i], h_STM.instr[i].name, 12);
913
914	if (h_STM.instr[i].len != 0 && h_STM.instr[i].reserved1 != 0)
915	{
916	allocateTmpInstr(1 + i);
917	setNoEnvelope(instrTmp[i]);
918
919	s = &instrTmp[1+i]->samp[0];
920
921	s->pek = NULL;
922	s->origPek = (int8_t *)malloc(h_STM.instr[i].len + LOOP_FIX_LEN);
923	if (s->origPek == NULL)
924	{
925	showMsg(0, "System message", "Not enough memory!");
926	goto stmLoadError;
927	}
928
929	s->pek = s->origPek + SMP_DAT_OFFSET;
930
931	s->len = h_STM.instr[i].len;
932	tuneSample(s, h_STM.instr[i].rate, false);
933	s->vol = h_STM.instr[i].vol;
934	s->repS = h_STM.instr[i].repS;
935	s->repL = h_STM.instr[i].repE - h_STM.instr[i].repS;
936	s->pan = 128;
937
938	if (s->repS < s->len && h_STM.instr[i].repE > s->repS && h_STM.instr[i].repE != 0xFFFF)
939	{
940	if (s->repS+s->repL > s->len)
941	s->repL = s->len - s->repS;
942
943	s->typ = 1; // enable loop
944	}
945	else
946	{
947	s->repS = 0;
948	s->repL = 0;
949	s->typ = 0;
950	}
951
952	if (s->vol > 64)
953	s->vol = 64;
954
955	if (fread(s->pek, s->len, 1, f) != 1)
956	{
957	showMsg(0, "System message", "General I/O error during loading! Possibly corrupt module?");
958	goto stmLoadError;
959	}
960
961	fixSample(s);
962	}
963	}
964
965	fclose(f);
966
967	moduleLoaded = true;
968	return true;
969
970	stmLoadError:
971	fclose(f);
972	freeTmpModule();
973	moduleFailedToLoad = true;
974	return false;
975	}
976
977	static int8_t countS3MChannels(uint16_t antPtn)
978	{	49	{
979	int32_t channels = 0;	50	"xm", "ft", "nst", "stk", "mod", "s3m", "stm", "fst", "digi",
980	for (int32_t i = 0; i < antPtn; i++)
981	{
982	if (pattTmp[i] == NULL)
983	continue;
984		51
985	tonTyp *ton = pattTmp[i];	52	"END_OF_LIST" // do NOT move, remove or edit this line!
986	for (int32_t j = 0; j < 64; j++)	53	};
987	{
988	for (int32_t k = 0; k < MAX_VOICES; k++, ton++)
989	{
990	if (ton->eff == 0 && ton->effTyp == 0 && ton->instr == 0 && ton->ton == 0 && ton->vol == 0)
991	continue;
992		54
993	if (k > channels)	55	// globals for module loaders
994	channels = k;	56	volatile bool tmpLinearPeriodsFlag;
995	}	57	int16_t pattLensTmp[MAX_PATTERNS];
996	}	58	tonTyp *pattTmp[MAX_PATTERNS];
997	}	59	instrTyp *instrTmp[1+256];
998	channels++;	60	songTyp songTmp;
		61	// --------------------------
999		62
1000	return (int8_t)channels;	63	static volatile bool musicIsLoading, moduleLoaded, moduleFailedToLoad;
1001	}	64	static SDL_Thread *thread;
		65	static uint8_t oldPlayMode;
		66	static void setupLoadedModule(void);
		67	static void freeTmpModule(void);
1002		68
1003	static bool loadMusicS3M(FILE *f, uint32_t dataLength, bool externalThreadFlag)	69	// Crude module detection routine. These aren't always accurate detections!
		70	static int8_t detectModule(FILE *f)
1004	{	71	{
1005	int8_t *tmpSmp;	72	uint8_t D[256], I[4];
1006	uint8_t ha[2048];
1007	uint8_t alastnfo[32], alastefx[32], alastvibnfo[32], s3mLastGInstr[32];
1008	uint8_t typ;
1009	int16_t ai, ap, ver, ii, kk, tmp;
1010	uint16_t ptnOfs[256];
1011	int32_t i, j, k, len;
1012	tonTyp ton;
1013	sampleTyp *s;
1014	songS3MHeaderTyp h_S3M;
1015	songS3MinstrHeaderTyp h_S3MInstr;
1016	int16_t (showMsg)(int16_t, const char , const char *);
1017
1018	showMsg = externalThreadFlag ? okBoxThreadSafe : okBox;
1019		73
		74	fseek(f, 0, SEEK_END);
		75	uint32_t fileLength = (uint32_t)ftell(f);
1020	rewind(f);	76	rewind(f);
1021		77
1022	// start loading S3M	78	memset(D, 0, sizeof (D));
1023		79	fread(D, 1, sizeof (D), f);
1024	if (fread(&h_S3M, 1, sizeof (h_S3M), f) != sizeof (h_S3M))	80	fseek(f, 1080, SEEK_SET); // MOD ID
1025	return loadMusicSTM(f, dataLength, externalThreadFlag); // not a .s3m, try loading as .stm	81	I[0] = I[1] = I[2] = I[3] = 0;
1026		82	fread(I, 1, 4, f);
1027	if (memcmp(h_S3M.id, "SCRM", 4))	83	rewind(f);
1028	return loadMusicSTM(f, dataLength, externalThreadFlag); // not a .s3m, try loading as .stm
1029		84
1030	loadedFormat = FORMAT_S3M;	85	// DIGI Booster (non-Pro)
		86	if (!memcmp("DIGI Booster module", &D[0x00], 19+1) && D[0x19] >= 1 && D[0x19] <= 8)
		87	return FORMAT_DIGI;
1031		88
1032	if (h_S3M.antInstr > MAX_INST \|\| h_S3M.songTabLen > 256 \|\| h_S3M.antPatt > 256 \|\|	89	// Scream Tracker 3 S3M (and compatible trackers)
1033	h_S3M.typ != 16 \|\| h_S3M.ver < 1 \|\| h_S3M.ver > 2)	90	if (!memcmp("SCRM", &D[0x2C], 4) && D[0x1D] == 16) // XXX: byte=16 in all cases?
1034	{	91	return FORMAT_S3M;
1035	showMsg(0, "System message", "Error loading .s3m: Incompatible module!");
1036	goto s3mLoadError;
1037	}
1038		92
1039	memset(songTmp.songTab, 255, sizeof (songTmp.songTab));	93	// Scream Tracker 2 STM
1040	if (fread(songTmp.songTab, h_S3M.songTabLen, 1, f) != 1)	94	if ((!memcmp("!Scream!", &D[0x14], 8) \|\| !memcmp("BMOD2STM", &D[0x14], 8) \|\|
		95	!memcmp("WUZAMOD!", &D[0x14], 8) \|\| !memcmp("SWavePro", &D[0x14], 8)) && D[0x1D] == 2) // XXX: byte=2 for "WUZAMOD!"/"SWavePro" ?
1041	{	96	{
1042	showMsg(0, "System message", "General I/O error during loading! Is the file in use?");	97	return FORMAT_STM;
1043	goto s3mLoadError;
1044	}	98	}
1045		99
1046	songTmp.len = h_S3M.songTabLen;	100	// Generic multi-channel MOD (1..9 channels)
1047		101	if (isdigit(I[0]) && I[0] != '0' && I[1] == 'C' && I[2] == 'H' && I[3] == 'N') // xCHN
1048	// remove pattern separators (254)	102	return FORMAT_MOD;
1049	k = 0;
1050	j = 0;
1051	for (i = 0; i < songTmp.len; i++)
1052	{
1053	if (songTmp.songTab[i] != 254)
1054	songTmp.songTab[j++] = songTmp.songTab[i];
1055	else
1056	k++;
1057	}
1058		103
1059	if (k <= songTmp.len)	104	// Generic multi-channel MOD (10..99 channels)
1060	songTmp.len -= (uint16_t)k;	105	if (isdigit(I[0]) && isdigit(I[1]) && I[0] != '0' && I[2] == 'C' && I[3] == 'H') // xxCH
1061	else	106	return FORMAT_MOD;
1062	songTmp.len = 1;
1063		107
1064	for (i = 1; i < songTmp.len; i++)	108	// Generic multi-channel MOD (10..99 channels)
1065	{	109	if (isdigit(I[0]) && isdigit(I[1]) && I[0] != '0' && I[2] == 'C' && I[3] == 'N') // xxCN (same as xxCH)
1066	if (songTmp.songTab[i] == 255)	110	return FORMAT_MOD;
1067	{
1068	songTmp.len = (uint16_t)i;
1069	break;
1070	}
1071	}
1072		111
1073	// clear unused song table entries	112	// Generic 4-channel MOD (NoiseTracker/ProTracker or compatible)
1074	if (songTmp.len < 255)	113	if (!memcmp("M.K.", I, 4) \|\| !memcmp("M!K!", I, 4) \|\| !memcmp("NSMS", I, 4) \|\|
1075	memset(&songTmp.songTab[songTmp.len], 0, 255-songTmp.len);	114	!memcmp("LARD", I, 4) \|\| !memcmp("PATT", I, 4) \|\| !memcmp("PATT", I, 4) \|\|
1076		115	!memcmp("FLT4", I, 4) \|\| !memcmp("FLT8", I, 4) \|\| !memcmp("N.T.", I, 4) \|\|
1077	songTmp.speed = h_S3M.defTempo;	116	!memcmp("M&K!", I, 4) \|\| !memcmp("FEST", I, 4))
1078	if (songTmp.speed < 32)
1079	songTmp.speed = 32;
1080
1081	songTmp.tempo = h_S3M.defSpeed;
1082	if (songTmp.tempo == 0)
1083	songTmp.tempo = 6;
1084
1085	if (songTmp.tempo > 31)
1086	songTmp.tempo = 31;
1087
1088	songTmp.initialTempo = songTmp.tempo;
1089
1090	// trim off spaces at end of name
1091	for (i = 19; i >= 0; i--)
1092	{
1093	if (h_S3M.name[i] == ' ' \|\| h_S3M.name[i] == 0x1A)
1094	h_S3M.name[i] = '\0';
1095	else
1096	break;
1097	}
1098
1099	memcpy(songTmp.name, h_S3M.name, 20);
1100	songTmp.name[20] = '\0';
1101
1102	ap = h_S3M.antPatt;
1103	ai = h_S3M.antInstr;
1104	ver = h_S3M.ver;
1105
1106	k = 31;
1107	while (k >= 0 && h_S3M.chanType[k] >= 16) k--;
1108	songTmp.antChn = (k + 2) & 254;
1109
1110	if (fread(ha, ai + ai, 1, f) != 1)
1111	{
1112	showMsg(0, "System message", "General I/O error during loading! Is the file in use?");
1113	goto s3mLoadError;
1114	}
1115
1116	if (fread(ptnOfs, ap + ap, 1, f) != 1)
1117	{
1118	showMsg(0, "System message", "General I/O error during loading! Is the file in use?");
1119	goto s3mLoadError;
1120	}
1121
1122	// * PATTERNS *
1123
1124	k = 0;
1125	for (i = 0; i < ap; i++)
1126	{	117	{
1127	if (ptnOfs[i] == 0)	118	return FORMAT_MOD;
1128	continue; // empty pattern
1129
1130	memset(alastnfo, 0, sizeof (alastnfo));
1131	memset(alastefx, 0, sizeof (alastefx));
1132	memset(alastvibnfo, 0, sizeof (alastvibnfo));
1133	memset(s3mLastGInstr, 0, sizeof (s3mLastGInstr));
1134
1135	fseek(f, ptnOfs[i] << 4, SEEK_SET);
1136	if (feof(f))
1137	continue;
1138
1139	if (fread(&j, 2, 1, f) != 1)
1140	{
1141	showMsg(0, "System message", "General I/O error during loading! Is the file in use?");
1142	goto s3mLoadError;
1143	}
1144
1145	if (j > 0 && j <= 12288)
1146	{
1147	pattTmp[i] = (tonTyp )calloc((MAX_PATT_LEN TRACK_WIDTH) + 16, 1);
1148	if (pattTmp[i] == NULL)
1149	{
1150	showMsg(0, "System message", "Not enough memory!");
1151	goto s3mLoadError;
1152	}
1153
1154	pattLensTmp[i] = 64;
1155	fread(pattBuff, j, 1, f);
1156
1157	k = 0;
1158	kk = 0;
1159
1160	while (k < j && kk < 64)
1161	{
1162	typ = pattBuff[k++];
1163
1164	if (typ == 0)
1165	{
1166	kk++;
1167	}
1168	else
1169	{
1170	ii = typ & 31;
1171
1172	memset(&ton, 0, sizeof (ton));
1173
1174	// note and sample
1175	if (typ & 32)
1176	{
1177	ton.ton = pattBuff[k++];
1178	ton.instr = pattBuff[k++];
1179
1180	if (ton.instr > MAX_INST)
1181	ton.instr = 0;
1182
1183	if (ton.ton == 254) ton.ton = 97;
1184	else if (ton.ton == 255) ton.ton = 0;
1185	else
1186	{
1187	ton.ton = 1 + (ton.ton & 0xF) + (ton.ton >> 4) * 12;
1188	if (ton.ton > 96)
1189	ton.ton = 0;
1190	}
1191	}
1192
1193	// volume column
1194	if (typ & 64)
1195	{
1196	ton.vol = pattBuff[k++];
1197
1198	if (ton.vol <= 64)
1199	ton.vol += 0x10;
1200	else
1201	ton.vol = 0;
1202	}
1203
1204	// effect
1205	if (typ & 128)
1206	{
1207	ton.effTyp = pattBuff[k++];
1208	ton.eff = pattBuff[k++];
1209
1210	if (ton.eff > 0)
1211	{
1212	alastnfo[ii] = ton.eff;
1213	if (ton.effTyp == 8 \|\| ton.effTyp == 21)
1214	alastvibnfo[ii] = ton.eff; // H/U
1215	}
1216
1217	// in ST3, a lot of effects directly share the same memory!
1218	if (ton.eff == 0 && ton.effTyp != 7) // G
1219	{
1220	uint8_t efx = ton.effTyp;
1221	if (efx == 8 \|\| efx == 21) // H/U
1222	ton.eff = alastvibnfo[ii];
1223	else if ((efx >= 4 && efx <= 12) \|\| (efx >= 17 && efx <= 19)) // D/E/F/I/J/K/L/Q/R/S
1224	ton.eff = alastnfo[ii];
1225
1226	/* If effect data is zero and effect type was the same as last one, clear out
1227	** data if it's not J or S (those have no memory in the equivalent XM effects).
1228	** Also goes for extra fine pitch slides and fine volume slides,
1229	** since they get converted to other effects.
1230	*/
1231	if (efx == alastefx[ii] && ton.effTyp != 10 && ton.effTyp != 19) // J/S
1232	{
1233	uint8_t nfo = ton.eff;
1234	bool extraFinePitchSlides = (efx == 5 \|\| efx == 6) && ((nfo & 0xF0) == 0xE0);
1235	bool fineVolSlides = (efx == 4 \|\| efx == 11) &&
1236	((nfo > 0xF0) \|\| (((nfo & 0xF) == 0xF) && ((nfo & 0xF0) > 0)));
1237
1238	if (!extraFinePitchSlides && !fineVolSlides)
1239	ton.eff = 0;
1240	}
1241	}
1242
1243	if (ton.effTyp > 0)
1244	alastefx[ii] = ton.effTyp;
1245
1246	switch (ton.effTyp)
1247	{
1248	case 1: // A
1249	{
1250	ton.effTyp = 0xF;
1251	if (ton.eff == 0 \|\| ton.eff > 0x1F)
1252	{
1253	ton.effTyp = 0;
1254	ton.eff = 0;
1255	}
1256	}
1257	break;
1258
1259	case 2: ton.effTyp = 0xB; break; // B
1260	case 3: ton.effTyp = 0xD; break; // C
1261	case 4: // D
1262	{
1263	if (ton.eff > 0xF0) // fine slide up
1264	{
1265	ton.effTyp = 0xE;
1266	ton.eff = 0xB0 \| (ton.eff & 0xF);
1267	}
1268	else if ((ton.eff & 0x0F) == 0x0F && (ton.eff & 0xF0) > 0) // fine slide down
1269	{
1270	ton.effTyp = 0xE;
1271	ton.eff = 0xA0 \| (ton.eff >> 4);
1272	}
1273	else
1274	{
1275	ton.effTyp = 0xA;
1276	if (ton.eff & 0x0F) // on D/K, last nybble has first priority in ST3
1277	ton.eff &= 0x0F;
1278	}
1279	}
1280	break;
1281
1282	case 5: // E
1283	case 6: // F
1284	{
1285	if ((ton.eff & 0xF0) >= 0xE0)
1286	{
1287	// convert to fine slide
1288	if ((ton.eff & 0xF0) == 0xE0)
1289	tmp = 0x21;
1290	else
1291	tmp = 0xE;
1292
1293	ton.eff &= 0x0F;
1294
1295	if (ton.effTyp == 0x05)
1296	ton.eff \|= 0x20;
1297	else
1298	ton.eff \|= 0x10;
1299
1300	ton.effTyp = (uint8_t)tmp;
1301
1302	if (ton.effTyp == 0x21 && ton.eff == 0)
1303	{
1304	ton.effTyp = 0;
1305	}
1306	}
1307	else
1308	{
1309	// convert to normal 1xx/2xx slide
1310	ton.effTyp = 7 - ton.effTyp;
1311	}
1312	}
1313	break;
1314
1315	case 7: // G
1316	{
1317	ton.effTyp = 0x03;
1318
1319	// fix illegal slides (to new instruments)
1320	if (ton.instr != 0 && ton.instr != s3mLastGInstr[ii])
1321	ton.instr = s3mLastGInstr[ii];
1322	}
1323	break;
1324
1325	case 11: // K
1326	{
1327	if (ton.eff > 0xF0) // fine slide up
1328	{
1329	ton.effTyp = 0xE;
1330	ton.eff = 0xB0 \| (ton.eff & 0xF);
1331
1332	// if volume column is unoccupied, set to vibrato
1333	if (ton.vol == 0)
1334	ton.vol = 0xB0;
1335	}
1336	else if ((ton.eff & 0x0F) == 0x0F && (ton.eff & 0xF0) > 0) // fine slide down
1337	{
1338	ton.effTyp = 0xE;
1339	ton.eff = 0xA0 \| (ton.eff >> 4);
1340
1341	// if volume column is unoccupied, set to vibrato
1342	if (ton.vol == 0)
1343	ton.vol = 0xB0;
1344	}
1345	else
1346	{
1347	ton.effTyp = 0x6;
1348	if (ton.eff & 0x0F) // on D/K, last nybble has first priority in ST3
1349	ton.eff &= 0x0F;
1350	}
1351	}
1352	break;
1353
1354	case 8: ton.effTyp = 0x04; break; // H
1355	case 9: ton.effTyp = 0x1D; break; // I
1356	case 10: ton.effTyp = 0x00; break; // J
1357	case 12: ton.effTyp = 0x05; break; // L
1358	case 15: ton.effTyp = 0x09; break; // O
1359	case 17: ton.effTyp = 0x1B; break; // Q
1360	case 18: ton.effTyp = 0x07; break; // R
1361
1362	case 19: // S
1363	{
1364	ton.effTyp = 0xE;
1365	tmp = ton.eff >> 4;
1366	ton.eff &= 0x0F;
1367
1368	if (tmp == 0x1) ton.eff \|= 0x30;
1369	else if (tmp == 0x2) ton.eff \|= 0x50;
1370	else if (tmp == 0x3) ton.eff \|= 0x40;
1371	else if (tmp == 0x4) ton.eff \|= 0x70;
1372	// ignore S8x becuase it's not compatible with FT2 panning
1373	else if (tmp == 0xB) ton.eff \|= 0x60;
1374	else if (tmp == 0xC) // Note Cut
1375	{
1376	ton.eff \|= 0xC0;
1377	if (ton.eff == 0xC0)
1378	{
1379	// EC0 does nothing in ST3 but cuts voice in FT2, remove effect
1380	ton.effTyp = 0;
1381	ton.eff = 0;
1382	}
1383	}
1384	else if (tmp == 0xD) // Note Delay
1385	{
1386	ton.eff \|= 0xD0;
1387	if (ton.ton == 0 \|\| ton.ton == 97)
1388	{
1389	// EDx without a note does nothing in ST3 but retrigs in FT2, remove effect
1390	ton.effTyp = 0;
1391	ton.eff = 0;
1392	}
1393	else if (ton.eff == 0xD0)
1394	{
1395	// ED0 prevents note/smp/vol from updating in ST3, remove everything
1396	ton.ton = 0;
1397	ton.instr = 0;
1398	ton.vol = 0;
1399	ton.effTyp = 0;
1400	ton.eff = 0;
1401	}
1402	}
1403	else if (tmp == 0xE) ton.eff \|= 0xE0;
1404	else if (tmp == 0xF) ton.eff \|= 0xF0;
1405	else
1406	{
1407	ton.effTyp = 0;
1408	ton.eff = 0;
1409	}
1410	}
1411	break;
1412
1413	case 20: // T
1414	{
1415	ton.effTyp = 0x0F;
1416	if (ton.eff < 0x21) // Txx with a value lower than 33 (0x21) does nothing in ST3, remove effect
1417	{
1418	ton.effTyp = 0;
1419	ton.eff = 0;
1420	}
1421	}
1422	break;
1423
1424	case 22: // V
1425	{
1426	ton.effTyp = 0x10;
1427	if (ton.eff > 0x40)
1428	{
1429	// Vxx > 0x40 does nothing in ST3
1430	ton.effTyp = 0;
1431	ton.eff = 0;
1432	}
1433	}
1434	break;
1435
1436	default:
1437	{
1438	ton.effTyp = 0;
1439	ton.eff = 0;
1440	}
1441	break;
1442	}
1443	}
1444
1445	if (ton.instr != 0 && ton.effTyp != 0x3)
1446	s3mLastGInstr[ii] = ton.instr;
1447
1448	if (ton.effTyp > 35)
1449	{
1450	ton.effTyp = 0;
1451	ton.eff = 0;
1452	}
1453
1454	pattTmp[i][(kk * MAX_VOICES) + ii] = ton;
1455	}
1456	}
1457
1458	if (tmpPatternEmpty((uint16_t)i))
1459	{
1460	if (pattTmp[i] != NULL)
1461	{
1462	free(pattTmp[i]);
1463	pattTmp[i] = NULL;
1464	}
1465	}
1466	}
1467	}	119	}
1468		120
1469	// * SAMPLES *	121	/* Check if the file is a .it module (Impulse Tracker, not supported).
1470		122	** Some people may attempt to load .IT files in the FT2 clone, so
1471	bool adlibInsWarn = false;	123	** reject them here instead of accidentally loading them as .STK
1472		124	*/
1473	memcpy(ptnOfs, ha, 512);	125	if (!memcmp("IMPM", D, 4) && D[0x16] == 0)
1474	for (i = 0; i < ai; i++)	126	return FORMAT_UNKNOWN;
1475	{
1476	fseek(f, ptnOfs[i] << 4, SEEK_SET);
1477
1478	if (fread(&h_S3MInstr, 1, sizeof (h_S3MInstr), f) != sizeof (h_S3MInstr))
1479	{
1480	showMsg(0, "System message", "Not enough memory!");
1481	goto s3mLoadError;
1482	}
1483
1484	// trim off spaces at end of name
1485	for (j = 21; j >= 0; j--)
1486	{
1487	if (h_S3MInstr.name[j] == ' ' \|\| h_S3MInstr.name[j] == 0x1A)
1488	h_S3MInstr.name[j] = '\0';
1489	else
1490	break;
1491	}
1492
1493	memcpy(songTmp.instrName[1+i], h_S3MInstr.name, 22);
1494	songTmp.instrName[1+i][22] = '\0';
1495
1496	if (h_S3MInstr.typ == 2)
1497	{
1498	adlibInsWarn = true;
1499	}
1500	else if (h_S3MInstr.typ == 1)
1501	{
1502	if ((h_S3MInstr.flags & (255-1-2-4)) != 0 \|\| h_S3MInstr.pack != 0)
1503	{
1504	showMsg(0, "System message", "Error loading .s3m: Incompatible module!");
1505	goto s3mLoadError;
1506	}
1507	else if (h_S3MInstr.memSeg > 0 && h_S3MInstr.len > 0)
1508	{
1509	if (!allocateTmpInstr((int16_t)(1 + i)))
1510	{
1511	showMsg(0, "System message", "Not enough memory!");
1512	goto s3mLoadError;
1513	}
1514
1515	setNoEnvelope(instrTmp[1 + i]);
1516	s = &instrTmp[1+i]->samp[0];
1517
1518	len = h_S3MInstr.len;
1519
1520	bool hasLoop = h_S3MInstr.flags & 1;
1521	bool stereoSample = (h_S3MInstr.flags >> 1) & 1;
1522	bool is16Bit = (h_S3MInstr.flags >> 2) & 1;
1523
1524	if (is16Bit) // 16-bit
1525	len <<= 1;
1526
1527	if (stereoSample) // stereo
1528	len <<= 1;
1529
1530	tmpSmp = (int8_t *)malloc(len + LOOP_FIX_LEN);
1531	if (tmpSmp == NULL)
1532	{
1533	showMsg(0, "System message", "Not enough memory!");
1534	goto s3mLoadError;
1535	}
1536
1537	int8_t *newPtr = tmpSmp + SMP_DAT_OFFSET;
1538
1539	memcpy(s->name, h_S3MInstr.name, 21);
1540
1541	if (h_S3MInstr.c2Spd > 65535) // ST3 (and OpenMPT) does this
1542	h_S3MInstr.c2Spd = 65535;
1543
1544	tuneSample(s, h_S3MInstr.c2Spd, false);
1545
1546	s->len = h_S3MInstr.len;
1547	s->vol = h_S3MInstr.vol;
1548	s->repS = h_S3MInstr.repS;
1549	s->repL = h_S3MInstr.repE - h_S3MInstr.repS;
1550
1551	// non-FT2: fixes "miracle man.s3m"
1552	if ((h_S3MInstr.memSeg<<4)+s->len > (int32_t)dataLength)
1553	s->len = dataLength - (h_S3MInstr.memSeg << 4);
1554
1555	if (s->repL <= 2 \|\| s->repS+s->repL > s->len)
1556	{
1557	s->repS = 0;
1558	s->repL = 0;
1559	hasLoop = false;
1560	}
1561
1562	if (s->repL == 0)
1563	hasLoop = false;
1564
1565	s->typ = hasLoop + (is16Bit << 4);
1566
1567	if (s->vol > 64)
1568	s->vol = 64;
1569
1570	s->pan = 128;
1571
1572	fseek(f, h_S3MInstr.memSeg << 4, SEEK_SET);
1573
1574	// non-FT2: fixes "miracle man.s3m"
1575	if ((h_S3MInstr.memSeg<<4)+len > (int32_t)dataLength)
1576	len = dataLength - (h_S3MInstr.memSeg << 4);
1577
1578	if (ver == 1)
1579	{
1580	fseek(f, len, SEEK_CUR); // sample not supported
1581	}
1582	else
1583	{
1584	if (fread(newPtr, len, 1, f) != 1)
1585	{
1586	free(tmpSmp);
1587	showMsg(0, "System message", "General I/O error during loading! Is the file in use?");
1588	goto s3mLoadError;
1589	}
1590
1591	if (is16Bit)
1592	{
1593	conv16BitSample(newPtr, len, stereoSample);
1594
1595	s->origPek = tmpSmp;
1596	s->pek = s->origPek + SMP_DAT_OFFSET;
1597
1598	s->len <<= 1;
1599	s->repS <<= 1;
1600	s->repL <<= 1;
1601	}
1602	else
1603	{
1604	conv8BitSample(newPtr, len, stereoSample);
1605
1606	s->origPek = tmpSmp;
1607	s->pek = s->origPek + SMP_DAT_OFFSET;
1608	}
1609
1610	// if stereo sample: reduce memory footprint after sample was downmixed to mono
1611	if (stereoSample)
1612	{
1613	newPtr = (int8_t *)realloc(s->origPek, s->len + LOOP_FIX_LEN);
1614	if (newPtr != NULL)
1615	{
1616	s->origPek = newPtr;
1617	s->pek = s->origPek + SMP_DAT_OFFSET;
1618	}
1619	}
1620
1621	fixSample(s);
1622	}
1623	}
1624	}
1625	}
1626		127
1627	fclose(f);	128	/* Fasttracker II XM and compatible trackers.
		129	** Note: This test can falsely be true for STK modules (and non-supported files) where the
		130	** first 17 bytes start with "Extended Module: ". This is unlikely to happen.
		131	*/
		132	if (!memcmp("Extended Module: ", &D[0x00], 17))
		133	return FORMAT_XM;
1628		134
1629	songTmp.antChn = countS3MChannels(ap);	135	/* Lastly, we assume that the file is either a 15-sample STK or an unsupported file.
		136	** Let's assume it's an STK and do some sanity checks. If they fail, we have an
		137	** unsupported file.
		138	*/
1630		139
1631	if (adlibInsWarn)	140	// minimum and maximum (?) possible size for a supported STK
1632	showMsg(0, "System message", "Warning: The module contains unsupported AdLib instruments!");	141	if (fileLength < 1624 \|\| fileLength > 984634)
		142	return FORMAT_UNKNOWN;
1633		143
1634	if (!(config.dontShowAgainFlags & DONT_SHOW_S3M_LOAD_WARNING_FLAG))	144	// test STK numOrders+BPM for illegal values
1635	showMsg(6, "System message", "Warning: S3M channel panning is ignored because it's not compatible with FT2.");	145	fseek(f, 470, SEEK_SET);
		146	D[0] = D[1] = 0;
		147	fread(D, 1, 2, f);
		148	rewind(f);
1636		149
1637	moduleLoaded = true;	150	if (D[0] >= 0 && D[0] <= 128 && D[1] <= 220)
1638	return true;	151	return FORMAT_POSSIBLY_STK;
1639		152
1640	s3mLoadError:	153	return FORMAT_UNKNOWN;
1641	fclose(f);
1642	freeTmpModule();
1643	moduleFailedToLoad = true;
1644	return false;
1645	}	154	}
1646		155
1647	bool doLoadMusic(bool externalThreadFlag)	156	static bool doLoadMusic(bool externalThreadFlag)
1648	{	157	{
1649	char tmpText[128];	158	// setup message box functions
1650	int16_t k;	159	loaderMsgBox = externalThreadFlag ? myLoaderMsgBoxThreadSafe : myLoaderMsgBox;
1651	uint16_t i;	160	loaderSysReq = externalThreadFlag ? okBoxThreadSafe : okBox;
1652	uint32_t filelength;
1653	songHeaderTyp h;
1654	FILE *f;
1655	int16_t (showMsg)(int16_t, const char , const char *);
1656
1657	showMsg = externalThreadFlag ? okBoxThreadSafe : okBox;
1658
1659	linearFreqTable = false;
1660		161
1661	if (editor.tmpFilenameU == NULL)	162	if (editor.tmpFilenameU == NULL)
1662	{	163	{
1663	showMsg(0, "System message", "Generic memory fault during loading!");	164	loaderMsgBox("Generic memory fault during loading!");
1664	moduleFailedToLoad = true;	165	goto loadError;
1665	return false;
1666	}	166	}
1667		167
1668	f = UNICHAR_FOPEN(editor.tmpFilenameU, "rb");	168	FILE *f = UNICHAR_FOPEN(editor.tmpFilenameU, "rb");
1669	if (f == NULL)	169	if (f == NULL)
1670	{	170	{
1671	showMsg(0, "System message", "General I/O error during loading! Is the file in use? Does it exist?");	171	loaderMsgBox("General I/O error during loading! Is the file in use? Does it exist?");
1672	moduleFailedToLoad = true;	172	goto loadError;
1673	return false;
1674	}	173	}
1675		174
		175	int8_t format = detectModule(f);
1676	fseek(f, 0, SEEK_END);	176	fseek(f, 0, SEEK_END);
1677	filelength = ftell(f);	177	uint32_t filesize = ftell(f);
1678	rewind(f);
1679
1680	// start loading
1681	if (fread(&h, 1, sizeof (h), f) != sizeof (h))
1682	return loadMusicS3M(f, filelength, externalThreadFlag); // not a .xm file, try to load as .s3m
1683
1684	if (memcmp(h.sig, "Extended Module: ", 17))
1685	return loadMusicS3M(f, filelength, externalThreadFlag); // not a .xm file, try to load as .s3m
1686
1687	loadedFormat = FORMAT_XM;
1688
1689	if (h.ver < 0x0102 \|\| h.ver > 0x0104)
1690	{
1691	fclose(f);
1692
1693	const int32_t major = (h.ver >> 8) & 0x0F;
1694	const int32_t minor = h.ver & 0xFF;
1695
1696	sprintf(tmpText, "Error loading XM: Unsupported file version (v%01X.%02X).", major, minor);
1697	showMsg(0, "System message", tmpText);
1698
1699	moduleFailedToLoad = true;
1700	return false;
1701	}
1702
1703	if (h.len > MAX_ORDERS)
1704	{
1705	showMsg(0, "System message", "Error loading XM: The song has more than 256 orders!");
1706	goto xmLoadError;
1707	}
1708
1709	if (h.antPtn > MAX_PATTERNS)
1710	{
1711	showMsg(0, "System message", "Error loading XM: The song has more than 256 patterns!");
1712	goto xmLoadError;
1713	}
1714
1715	if (h.antChn == 0)
1716	{
1717	showMsg(0, "System message", "Error loading XM: This file is corrupt.");
1718	goto xmLoadError;
1719	}
1720
1721	if (h.antInstrs > 256) // if >128 instruments, we fake-load up to 128 extra instruments and discard them
1722	{
1723	showMsg(0, "System message", "Error loading XM: This file is corrupt.");
1724	goto xmLoadError;
1725	}
1726
1727	fseek(f, 60 + h.headerSize, SEEK_SET);
1728	if (filelength != 336 && feof(f)) // 336 in length at this point = empty XM
1729	{
1730	showMsg(0, "System message", "Error loading XM: The module is empty!");
1731	goto xmLoadError;
1732	}
1733
1734	// trim off spaces at end of name
1735	for (k = 19; k >= 0; k--)
1736	{
1737	if (h.name[k] == ' ' \|\| h.name[k] == 0x1A)
1738	h.name[k] = '\0';
1739	else
1740	break;
1741	}
1742
1743	memcpy(songTmp.name, h.name, 20);
1744	songTmp.name[20] = '\0';
1745		178
1746	songTmp.len = h.len;	179	rewind(f);
1747	songTmp.repS = h.repS;	180	switch (format)
1748	songTmp.antChn = (uint8_t)h.antChn;
1749	songTmp.speed = h.defSpeed;
1750	songTmp.tempo = h.defTempo;
1751	songTmp.ver = h.ver;
1752	linearFreqTable = h.flags & 1;
1753
1754	songTmp.speed = CLAMP(songTmp.speed, 1, 999);
1755	songTmp.tempo = CLAMP(songTmp.tempo, 1, 99);
1756
1757	songTmp.initialTempo = songTmp.tempo;
1758
1759	if (songTmp.globVol > 64)
1760	songTmp.globVol = 64;
1761
1762	if (songTmp.len == 0)
1763	songTmp.len = 1; // songTmp.songTab is already empty
1764	else
1765	memcpy(songTmp.songTab, h.songTab, songTmp.len);
1766
1767	// some strange XMs have the order list padded with 0xFF, remove them!
1768	for (int16_t j = 255; j >= 0; j--)
1769	{
1770	if (songTmp.songTab[j] != 0xFF)
1771	break;
1772
1773	if (songTmp.len > j)
1774	songTmp.len = j;
1775	}
1776
1777	// even though XM supports 256 orders, FT2 supports only 255...
1778	if (songTmp.len > 0xFF)
1779	songTmp.len = 0xFF;
1780
1781	if (songTmp.ver < 0x0104)
1782	{
1783	// XM v1.02 and XM v1.03
1784
1785	for (i = 1; i <= h.antInstrs; i++)
1786	{
1787	if (!loadInstrHeader(f, i, externalThreadFlag))
1788	goto xmLoadError;
1789	}
1790
1791	if (!loadPatterns(f, h.antPtn, externalThreadFlag))
1792	goto xmLoadError;
1793
1794	for (i = 1; i <= h.antInstrs; i++)
1795	{
1796	if (!loadInstrSample(f, i, externalThreadFlag))
1797	goto xmLoadError;
1798	}
1799	}
1800	else
1801	{	181	{
1802	// XM v1.04 (latest version)	182	case FORMAT_XM: moduleLoaded = loadXM(f, filesize); break;
1803		183	case FORMAT_S3M: moduleLoaded = loadS3M(f, filesize); break;
1804	if (!loadPatterns(f, h.antPtn, externalThreadFlag))	184	case FORMAT_STM: moduleLoaded = loadSTM(f, filesize); break;
1805	goto xmLoadError;	185	case FORMAT_MOD: moduleLoaded = loadMOD(f, filesize); break;
		186	case FORMAT_POSSIBLY_STK: moduleLoaded = loadSTK(f, filesize); break;
		187	case FORMAT_DIGI: moduleLoaded = loadDIGI(f, filesize); break;
1806		188
1807	for (i = 1; i <= h.antInstrs; i++)	189	default:
1808	{	190	loaderMsgBox("This file is not a supported module!");
1809	if (!loadInstrHeader(f, i, externalThreadFlag))	191	break;
1810	goto xmLoadError;
1811
1812	if (!loadInstrSample(f, i, externalThreadFlag))
1813	goto xmLoadError;
1814	}
1815	}
1816
1817	// if we temporarily loaded more than 128 instruments, clear the extra allocated memory
1818	if (h.antInstrs > MAX_INST)
1819	{
1820	for (i = MAX_INST+1; i <= h.antInstrs; i++)
1821	{
1822	if (instrTmp[i] != NULL)
1823	{
1824	free(instrTmp[i]);
1825	instrTmp[i] = NULL;
1826	}
1827	}
1828	}	192	}
1829
1830	fclose(f);	193	fclose(f);
1831		194
1832	/* We support loading XMs with up to 32 samples per instrument (ModPlug/OpenMPT),	195	if (!moduleLoaded)
1833	** but only the first 16 will be loaded. Now make sure we set the number of samples	196	goto loadError;
1834	** back to max 16 in the headers before loading is done.
1835	*/
1836	bool instrHasMoreThan16Samples = false;
1837	for (i = 1; i <= MAX_INST; i++)
1838	{
1839	if (instrTmp[i] != NULL && instrTmp[i]->antSamp > MAX_SMP_PER_INST)
1840	{
1841	instrHasMoreThan16Samples = true;
1842	instrTmp[i]->antSamp = MAX_SMP_PER_INST;
1843	}
1844	}
1845
1846	if (songTmp.antChn > MAX_VOICES)
1847	{
1848	songTmp.antChn = MAX_VOICES;
1849	showMsg(0, "System message", "Warning: This XM contains >32 channels. The extra channels will be discarded!");
1850	}
1851
1852	if (h.antInstrs > MAX_INST)
1853	showMsg(0, "System message", "Warning: This XM contains >128 instruments. The extra instruments will be discarded!");
1854
1855	if (instrHasMoreThan16Samples)
1856	showMsg(0, "System message", "Warning: This XM contains instrument(s) with >16 samples. The extra samples will be discarded!");
1857		197
1858	moduleLoaded = true;	198	moduleLoaded = true;
1859	return true;	199	return true;
1860		200
1861	xmLoadError:	201	loadError:
1862	fclose(f);
1863	freeTmpModule();	202	freeTmpModule();
1864	moduleFailedToLoad = true;	203	moduleFailedToLoad = true;
1865	return false;	204	return false;
1866	}	205	}
1867		206
		207	static void clearTmpModule(void)
		208	{
		209	memset(pattTmp, 0, sizeof (pattTmp));
		210	memset(instrTmp, 0, sizeof (instrTmp));
		211	memset(&songTmp, 0, sizeof (songTmp));
		212
		213	for (uint32_t i = 0; i < MAX_PATTERNS; i++)
		214	pattLensTmp[i] = 64;
		215	}
		216
1868	static int32_t SDLCALL loadMusicThread(void *ptr)	217	static int32_t SDLCALL loadMusicThread(void *ptr)
1869	{	218	{
1870	return doLoadMusic(true);	219	return doLoadMusic(true);
1871
1872	(void)ptr;	220	(void)ptr;
1873	}	221	}
1874		222
1875	void loadMusic(UNICHAR *filenameU)	223	void loadMusic(UNICHAR *filenameU)
1876	{	224	{
1877	if (musicIsLoading)	225	if (musicIsLoading \|\| filenameU == NULL)
1878	return;	226	return;
1879		227
1880	mouseAnimOn();	228	mouseAnimOn();
@@ -1882,19 +230,9 @@ void loadMusic(UNICHAR *filenameU) · 1 unmodified line
1882	musicIsLoading = true;	230	musicIsLoading = true;
1883	moduleLoaded = false;	231	moduleLoaded = false;
1884	moduleFailedToLoad = false;	232	moduleFailedToLoad = false;
1885	loadedFormat = FORMAT_NONE;
1886		233
1887	UNICHAR_STRCPY(editor.tmpFilenameU, filenameU);	234	clearTmpModule(); // clear stuff from last loading session (very important)
1888		235	UNICHAR_STRCPY(editor.tmpFilenameU, filenameU);
1889	// clear deprecated pointers from possible last loading session (super important)
1890	memset(pattTmp, 0, sizeof (pattTmp));
1891	memset(instrTmp, 0, sizeof (instrTmp));
1892
1893	// prevent stuck instrument names from previous module
1894	memset(&songTmp, 0, sizeof (songTmp));
1895
1896	for (uint32_t i = 0; i < MAX_PATTERNS; i++)
1897	pattLensTmp[i] = 64;
1898		236
1899	thread = SDL_CreateThread(loadMusicThread, NULL, NULL);	237	thread = SDL_CreateThread(loadMusicThread, NULL, NULL);
1900	if (thread == NULL)	238	if (thread == NULL)
@@ -1910,19 +248,10 @@ void loadMusic(UNICHAR *filenameU) · 9 unmodified lines
1910		248
1911	bool loadMusicUnthreaded(UNICHAR *filenameU, bool autoPlay)	249	bool loadMusicUnthreaded(UNICHAR *filenameU, bool autoPlay)
1912	{	250	{
1913	if (filenameU == NULL \|\| editor.tmpFilenameU == NULL)	251	if (filenameU == NULL)
1914	return false;	252	return false;
1915		253
1916	// clear deprecated pointers from possible last loading session (super important)	254	clearTmpModule(); // clear stuff from last loading session (very important)
1917	memset(pattTmp, 0, sizeof (pattTmp));
1918	memset(instrTmp, 0, sizeof (instrTmp));
1919
1920	// prevent stuck instrument names from previous module
1921	memset(&songTmp, 0, sizeof (songTmp));
1922
1923	for (uint32_t i = 0; i < MAX_PATTERNS; i++)
1924	pattLensTmp[i] = 64;
1925
1926	UNICHAR_STRCPY(editor.tmpFilenameU, filenameU);	255	UNICHAR_STRCPY(editor.tmpFilenameU, filenameU);
1927		256
1928	editor.loadMusicEvent = EVENT_NONE;	257	editor.loadMusicEvent = EVENT_NONE;
@@ -1940,6 +269,36 @@ bool loadMusicUnthreaded(UNICHAR *filenameU, bool autoPlay) · 11 unmodified lines
1940	return false;	269	return false;
1941	}	270	}
1942		271
		272	bool allocateTmpPatt(int32_t nr, uint16_t rows)
		273	{
		274	pattTmp[nr] = (tonTyp )calloc((MAX_PATT_LEN TRACK_WIDTH) + 16, 1);
		275	if (pattTmp[nr] == NULL)
		276	return false;
		277
		278	pattLensTmp[nr] = rows;
		279	return true;
		280	}
		281
		282	bool allocateTmpInstr(int16_t nr)
		283	{
		284	if (instrTmp[nr] != NULL)
		285	return false; // already allocated
		286
		287	instrTyp p = (instrTyp )calloc(1, sizeof (instrTyp));
		288	if (p == NULL)
		289	return false;
		290
		291	sampleTyp *s = p->samp;
		292	for (int32_t i = 0; i < MAX_SMP_PER_INST; i++, s++)
		293	{
		294	s->pan = 128;
		295	s->vol = 64;
		296	}
		297
		298	instrTmp[nr] = p;
		299	return true;
		300	}
		301
1943	static void freeTmpModule(void) // called on module load error	302	static void freeTmpModule(void) // called on module load error
1944	{	303	{
1945	// free all patterns	304	// free all patterns
@@ -1970,404 +329,7 @@ static void freeTmpModule(void) // called on module load error · 24 unmodified lines
1970	}	329	}
1971	}	330	}
1972		331
1973	static bool loadInstrHeader(FILE *f, uint16_t i, bool externalThreadFlag)	332	bool tmpPatternEmpty(uint16_t nr)
1974	{
1975	int8_t k;
1976	uint8_t j;
1977	uint32_t readSize;
1978	instrHeaderTyp ih;
1979	instrTyp *ins;
1980	sampleHeaderTyp *src;
1981	sampleTyp *s;
1982	int16_t (showMsg)(int16_t, const char , const char *);
1983
1984	showMsg = externalThreadFlag ? okBoxThreadSafe : okBox;
1985
1986	memset(extraSampleLengths, 0, sizeof (extraSampleLengths));
1987	memset(&ih, 0, sizeof (ih));
1988	fread(&ih.instrSize, 4, 1, f);
1989
1990	readSize = ih.instrSize;
1991
1992	// yes, some XMs can have a header size of 0, and it usually means 263 bytes (INSTR_HEADER_SIZE)
1993	if (readSize == 0 \|\| readSize > INSTR_HEADER_SIZE)
1994	readSize = INSTR_HEADER_SIZE;
1995
1996	if (readSize < 4)
1997	{
1998	showMsg(0, "System message", "Error loading XM: This file is corrupt (or not supported)!");
1999	return false;
2000	}
2001
2002	// load instrument data into temp buffer
2003	fread(ih.name, readSize-4, 1, f); // -4 = skip ih.instrSize
2004
2005	// FT2 bugfix: skip instrument header data if instrSize is above INSTR_HEADER_SIZE
2006	if (ih.instrSize > INSTR_HEADER_SIZE)
2007	fseek(f, ih.instrSize-INSTR_HEADER_SIZE, SEEK_CUR);
2008
2009	if (ih.antSamp < 0 \|\| ih.antSamp > 32)
2010	{
2011	showMsg(0, "System message", "Error loading XM: This file is corrupt (or not supported)!");
2012	return false;
2013	}
2014
2015	if (i <= MAX_INST) // copy over instrument names
2016	{
2017	// trim off spaces at end of name
2018	for (k = 21; k >= 0; k--)
2019	{
2020	if (ih.name[k] == ' ' \|\| ih.name[k] == 0x1A)
2021	ih.name[k] = '\0';
2022	else
2023	break;
2024	}
2025
2026	memcpy(songTmp.instrName[i], ih.name, 22);
2027	songTmp.instrName[i][22] = '\0';
2028	}
2029
2030	if (ih.antSamp > 0)
2031	{
2032	if (!allocateTmpInstr(i))
2033	{
2034	showMsg(0, "System message", "Not enough memory!");
2035	return false;
2036	}
2037
2038	// copy instrument header elements to our instrument struct
2039
2040	ins = instrTmp[i];
2041	memcpy(ins->ta, ih.ta, 96);
2042	memcpy(ins->envVP, ih.envVP, 122sizeof(int16_t));
2043	memcpy(ins->envPP, ih.envPP, 122sizeof(int16_t));
2044	ins->envVPAnt = ih.envVPAnt;
2045	ins->envPPAnt = ih.envPPAnt;
2046	ins->envVSust = ih.envVSust;
2047	ins->envVRepS = ih.envVRepS;
2048	ins->envVRepE = ih.envVRepE;
2049	ins->envPSust = ih.envPSust;
2050	ins->envPRepS = ih.envPRepS;
2051	ins->envPRepE = ih.envPRepE;
2052	ins->envVTyp = ih.envVTyp;
2053	ins->envPTyp = ih.envPTyp;
2054	ins->vibTyp = ih.vibTyp;
2055	ins->vibSweep = ih.vibSweep;
2056	ins->vibDepth = ih.vibDepth;
2057	ins->vibRate = ih.vibRate;
2058	ins->fadeOut = ih.fadeOut;
2059	ins->midiOn = (ih.midiOn == 1) ? true : false;
2060	ins->midiChannel = ih.midiChannel;
2061	ins->midiProgram = ih.midiProgram;
2062	ins->midiBend = ih.midiBend;
2063	ins->mute = (ih.mute == 1) ? true : false;
2064	ins->antSamp = ih.antSamp; // used in loadInstrSample()
2065
2066	// sanitize stuff for broken/unsupported instruments
2067	ins->midiProgram = CLAMP(ins->midiProgram, 0, 127);
2068	ins->midiBend = CLAMP(ins->midiBend, 0, 36);
2069
2070	if (ins->midiChannel > 15) ins->midiChannel = 15;
2071	if (ins->vibDepth > 0x0F) ins->vibDepth = 0x0F;
2072	if (ins->vibRate > 0x3F) ins->vibRate = 0x3F;
2073	if (ins->vibTyp > 3) ins->vibTyp = 0;
2074
2075	for (j = 0; j < 96; j++)
2076	{
2077	if (ins->ta[j] >= MAX_SMP_PER_INST)
2078	ins->ta[j] = MAX_SMP_PER_INST-1;
2079	}
2080
2081	if (ins->envVPAnt > 12) ins->envVPAnt = 12;
2082	if (ins->envVRepS > 11) ins->envVRepS = 11;
2083	if (ins->envVRepE > 11) ins->envVRepE = 11;
2084	if (ins->envVSust > 11) ins->envVSust = 11;
2085	if (ins->envPPAnt > 12) ins->envPPAnt = 12;
2086	if (ins->envPRepS > 11) ins->envPRepS = 11;
2087	if (ins->envPRepE > 11) ins->envPRepE = 11;
2088	if (ins->envPSust > 11) ins->envPSust = 11;
2089
2090	for (j = 0; j < 12; j++)
2091	{
2092	if ((uint16_t)ins->envVP[j][0] > 32767) ins->envVP[j][0] = 32767;
2093	if ((uint16_t)ins->envPP[j][0] > 32767) ins->envPP[j][0] = 32767;
2094	if ((uint16_t)ins->envVP[j][1] > 64) ins->envVP[j][1] = 64;
2095	if ((uint16_t)ins->envPP[j][1] > 63) ins->envPP[j][1] = 63;
2096	}
2097
2098	int32_t sampleHeadersToRead = ih.antSamp;
2099	if (sampleHeadersToRead > MAX_SMP_PER_INST)
2100	sampleHeadersToRead = MAX_SMP_PER_INST;
2101
2102	if (fread(ih.samp, sampleHeadersToRead * sizeof (sampleHeaderTyp), 1, f) != 1)
2103	{
2104	showMsg(0, "System message", "General I/O error during loading!");
2105	return false;
2106	}
2107
2108	// if instrument contains more than 16 sample headers (unsupported), skip them
2109	if (ih.antSamp > MAX_SMP_PER_INST) // can only be 0..32 at this point
2110	{
2111	const int32_t samplesToSkip = ih.antSamp-MAX_SMP_PER_INST;
2112	for (j = 0; j < samplesToSkip; j++)
2113	{
2114	fread(&extraSampleLengths[j], 4, 1, f); // used for skipping data in loadInstrSample()
2115	fseek(f, sizeof (sampleHeaderTyp)-4, SEEK_CUR);
2116	}
2117	}
2118
2119	for (j = 0; j < sampleHeadersToRead; j++)
2120	{
2121	s = &instrTmp[i]->samp[j];
2122	src = &ih.samp[j];
2123
2124	// copy sample header elements to our sample struct
2125
2126	s->len = src->len;
2127	s->repS = src->repS;
2128	s->repL = src->repL;
2129	s->vol = src->vol;
2130	s->fine = src->fine;
2131	s->typ = src->typ;
2132	s->pan = src->pan;
2133	s->relTon = src->relTon;
2134	memcpy(s->name, src->name, 22);
2135	s->name[22] = '\0';
2136
2137	// dst->pek is set up later
2138
2139	// trim off spaces at end of name
2140	for (k = 21; k >= 0; k--)
2141	{
2142	if (s->name[k] == ' ' \|\| s->name[k] == 0x1A)
2143	s->name[k] = '\0';
2144	else
2145	break;
2146	}
2147
2148	// sanitize stuff broken/unsupported samples
2149	if (s->vol > 64)
2150	s->vol = 64;
2151
2152	s->relTon = CLAMP(s->relTon, -48, 71);
2153	}
2154	}
2155
2156	return true;
2157	}
2158
2159	void checkSampleRepeat(sampleTyp *s)
2160	{
2161	if (s->repS < 0) s->repS = 0;
2162	if (s->repL < 0) s->repL = 0;
2163	if (s->repS > s->len) s->repS = s->len;
2164	if (s->repS+s->repL > s->len) s->repL = s->len - s->repS;
2165	if (s->repL == 0) s->typ &= ~3; // non-FT2 fix: force loop off if looplen is 0
2166	}
2167
2168	static bool loadInstrSample(FILE *f, uint16_t i, bool externalThreadFlag)
2169	{
2170	int16_t (showMsg)(int16_t, const char , const char *);
2171
2172	showMsg = externalThreadFlag ? okBoxThreadSafe : okBox;
2173
2174	if (instrTmp[i] == NULL)
2175	return true; // empty instrument, let's just pretend it got loaded successfully
2176
2177	uint16_t k = instrTmp[i]->antSamp;
2178	if (k > MAX_SMP_PER_INST)
2179	k = MAX_SMP_PER_INST;
2180
2181	sampleTyp *s = instrTmp[i]->samp;
2182
2183	if (i > MAX_INST) // insNum > 128, just skip sample data
2184	{
2185	for (uint16_t j = 0; j < k; j++, s++)
2186	{
2187	if (s->len > 0)
2188	fseek(f, s->len, SEEK_CUR);
2189	}
2190	}
2191	else
2192	{
2193	for (uint16_t j = 0; j < k; j++, s++)
2194	{
2195	// if a sample has both forward loop and pingpong loop set, make it pingpong loop only (FT2 mixer behavior)
2196	if ((s->typ & 3) == 3)
2197	s->typ &= 0xFE;
2198
2199	int32_t l = s->len;
2200	if (l <= 0)
2201	{
2202	s->pek = NULL;
2203	s->len = 0;
2204	s->repL = 0;
2205	s->repS = 0;
2206
2207	if (s->typ & 32)
2208	s->typ &= ~32; // remove stereo flag
2209	}
2210	else
2211	{
2212	int32_t bytesToSkip = 0;
2213	if (l > MAX_SAMPLE_LEN)
2214	{
2215	bytesToSkip = l - MAX_SAMPLE_LEN;
2216	l = MAX_SAMPLE_LEN;
2217	}
2218
2219	s->pek = NULL;
2220	s->origPek = (int8_t *)malloc(l + LOOP_FIX_LEN);
2221	if (s->origPek == NULL)
2222	{
2223	showMsg(0, "System message", "Not enough memory!");
2224	return false;
2225	}
2226
2227	s->pek = s->origPek + SMP_DAT_OFFSET;
2228
2229	const int32_t bytesRead = (int32_t)fread(s->pek, 1, l, f);
2230	if (bytesRead < l)
2231	{
2232	const int32_t bytesToClear = l - bytesRead;
2233	memset(&s->pek[bytesRead], 0, bytesToClear);
2234	}
2235
2236	if (bytesToSkip > 0)
2237	fseek(f, bytesToSkip, SEEK_CUR);
2238
2239	delta2Samp(s->pek, l, s->typ);
2240
2241	if (s->typ & 32) // stereo sample - already downmixed to mono in delta2samp()
2242	{
2243	s->typ &= ~32; // remove stereo flag
2244
2245	s->len >>= 1;
2246	s->repL >>= 1;
2247	s->repS >>= 1;
2248
2249	int8_t newPtr = (int8_t )realloc(s->origPek, s->len + LOOP_FIX_LEN);
2250	if (newPtr != NULL)
2251	{
2252	s->origPek = newPtr;
2253	s->pek = s->origPek + SMP_DAT_OFFSET;
2254	}
2255	}
2256	}
2257
2258	// NON-FT2 FIX: Align to 2-byte if 16-bit sample
2259	if (s->typ & 16)
2260	{
2261	s->repL &= 0xFFFFFFFE;
2262	s->repS &= 0xFFFFFFFE;
2263	s->len &= 0xFFFFFFFE;
2264	}
2265
2266	checkSampleRepeat(s);
2267	fixSample(s);
2268	}
2269	}
2270
2271	if (instrTmp[i]->antSamp > MAX_SMP_PER_INST)
2272	{
2273	const int32_t samplesToSkip = instrTmp[i]->antSamp-MAX_SMP_PER_INST;
2274	for (i = 0; i < samplesToSkip; i++)
2275	{
2276	if (extraSampleLengths[i] > 0)
2277	fseek(f, extraSampleLengths[i], SEEK_CUR);
2278	}
2279	}
2280
2281	return true;
2282	}
2283
2284	void unpackPatt(uint8_t dst, uint8_t src, uint16_t len, int32_t antChn)
2285	{
2286	int32_t j;
2287
2288	if (dst == NULL)
2289	return;
2290
2291	const int32_t srcEnd = len * (sizeof (tonTyp) * antChn);
2292	int32_t srcIdx = 0;
2293
2294	int32_t numChannels = antChn;
2295	if (numChannels > MAX_VOICES)
2296	numChannels = MAX_VOICES;
2297
2298	const int32_t pitch = sizeof (tonTyp) * (MAX_VOICES - antChn);
2299	for (int32_t i = 0; i < len; i++)
2300	{
2301	for (j = 0; j < numChannels; j++)
2302	{
2303	if (srcIdx >= srcEnd)
2304	return; // error!
2305
2306	const uint8_t note = *src++;
2307	if (note & 0x80)
2308	{
2309	dst++ = (note & 0x01) ? src++ : 0;
2310	dst++ = (note & 0x02) ? src++ : 0;
2311	dst++ = (note & 0x04) ? src++ : 0;
2312	dst++ = (note & 0x08) ? src++ : 0;
2313	dst++ = (note & 0x10) ? src++ : 0;
2314	}
2315	else
2316	{
2317	*dst++ = note;
2318	dst++ = src++;
2319	dst++ = src++;
2320	dst++ = src++;
2321	dst++ = src++;
2322	}
2323
2324	// if note is overflowing (>97), remove it
2325	if (*(dst-5) > 97)
2326	*(dst-5) = 0;
2327
2328	// non-FT2 security fix: if effect is above 35 (Z), clear effect and parameter
2329	if (*(dst-2) > 35)
2330	{
2331	*(dst-2) = 0;
2332	*(dst-1) = 0;
2333	}
2334
2335	srcIdx += sizeof (tonTyp);
2336	}
2337
2338	// if more than 32 channels, skip rest of the channels for this row
2339	for (; j < antChn; j++)
2340	{
2341	if (srcIdx >= srcEnd)
2342	return; // error!
2343
2344	const uint8_t note = *src++;
2345	if (note & 0x80)
2346	{
2347	if (note & 0x01) src++;
2348	if (note & 0x02) src++;
2349	if (note & 0x04) src++;
2350	if (note & 0x08) src++;
2351	if (note & 0x10) src++;
2352	}
2353	else
2354	{
2355	src++;
2356	src++;
2357	src++;
2358	src++;
2359	}
2360
2361	srcIdx += sizeof (tonTyp);
2362	}
2363
2364	// if song has <32 channels, align pointer to next row (skip unused channels)
2365	if (antChn < MAX_VOICES)
2366	dst += pitch;
2367	}
2368	}
2369
2370	static bool tmpPatternEmpty(uint16_t nr)
2371	{	333	{
2372	if (pattTmp[nr] == NULL)	334	if (pattTmp[nr] == NULL)
2373	return true;	335	return true;
@@ -2396,97 +358,6 @@ void clearUnusedChannels(tonTyp *p, int16_t pattLen, int32_t antChn) · 22 unmodified lines
2396	memset(ptr, 0, width);	358	memset(ptr, 0, width);
2397	}	359	}
2398		360
2399	static bool loadPatterns(FILE *f, uint16_t antPtn, bool externalThreadFlag)
2400	{
2401	uint8_t tmpLen;
2402	patternHeaderTyp ph;
2403	int16_t (showMsg)(int16_t, const char , const char *);
2404
2405	showMsg = externalThreadFlag ? okBoxThreadSafe : okBox;
2406
2407	bool pattLenWarn = false;
2408	for (uint16_t i = 0; i < antPtn; i++)
2409	{
2410	if (fread(&ph.patternHeaderSize, 4, 1, f) != 1)
2411	goto pattCorrupt;
2412
2413	if (fread(&ph.typ, 1, 1, f) != 1)
2414	goto pattCorrupt;
2415
2416	ph.pattLen = 0;
2417	if (songTmp.ver == 0x0102)
2418	{
2419	if (fread(&tmpLen, 1, 1, f) != 1)
2420	goto pattCorrupt;
2421
2422	if (fread(&ph.dataLen, 2, 1, f) != 1)
2423	goto pattCorrupt;
2424
2425	ph.pattLen = tmpLen + 1; // +1 in v1.02
2426
2427	if (ph.patternHeaderSize > 8)
2428	fseek(f, ph.patternHeaderSize - 8, SEEK_CUR);
2429	}
2430	else
2431	{
2432	if (fread(&ph.pattLen, 2, 1, f) != 1)
2433	goto pattCorrupt;
2434
2435	if (fread(&ph.dataLen, 2, 1, f) != 1)
2436	goto pattCorrupt;
2437
2438	if (ph.patternHeaderSize > 9)
2439	fseek(f, ph.patternHeaderSize - 9, SEEK_CUR);
2440	}
2441
2442	if (feof(f))
2443	goto pattCorrupt;
2444
2445	pattLensTmp[i] = ph.pattLen;
2446	if (pattLensTmp[i] > MAX_PATT_LEN)
2447	{
2448	pattLensTmp[i] = MAX_PATT_LEN;
2449	pattLenWarn = true;
2450	}
2451
2452	if (ph.dataLen > 0)
2453	{
2454	pattTmp[i] = (tonTyp )calloc((MAX_PATT_LEN TRACK_WIDTH) + 16, 1);
2455	if (pattTmp[i] == NULL)
2456	{
2457	showMsg(0, "System message", "Not enough memory!");
2458	return false;
2459	}
2460
2461	if (fread(packedPattData, 1, ph.dataLen, f) != ph.dataLen)
2462	goto pattCorrupt;
2463
2464	unpackPatt((uint8_t *)pattTmp[i], packedPattData, pattLensTmp[i], songTmp.antChn);
2465	clearUnusedChannels(pattTmp[i], pattLensTmp[i], songTmp.antChn);
2466	}
2467
2468	if (tmpPatternEmpty(i))
2469	{
2470	if (pattTmp[i] != NULL)
2471	{
2472	free(pattTmp[i]);
2473	pattTmp[i] = NULL;
2474	}
2475
2476	pattLensTmp[i] = 64;
2477	}
2478	}
2479
2480	if (pattLenWarn)
2481	showMsg(0, "System message", "This module contains pattern(s) with a length above 256! They will be truncated.");
2482
2483	return true;
2484
2485	pattCorrupt:
2486	showMsg(0, "System message", "Error loading XM: This file is corrupt!");
2487	return false;
2488	}
2489
2490	// called from input/video thread after the module was done loading	361	// called from input/video thread after the module was done loading
2491	static void setupLoadedModule(void)	362	static void setupLoadedModule(void)
2492	{	363	{
@@ -2513,16 +384,28 @@ static void setupLoadedModule(void) · 20 unmodified lines
2513	pattLens[i] = pattLensTmp[i];	384	pattLens[i] = pattLensTmp[i];
2514	}	385	}
2515		386
		387	// copy over song struct
		388	memcpy(&song, &songTmp, sizeof (songTyp));
		389	fixSongName();
		390
2516	// copy over new instruments (includes sample pointers)	391	// copy over new instruments (includes sample pointers)
2517	for (int16_t i = 1; i <= MAX_INST; i++)	392	for (int16_t i = 1; i <= MAX_INST; i++)
2518	{	393	{
2519	instr[i] = instrTmp[i];	394	instr[i] = instrTmp[i];
2520	fixSampleName(i);	395	fixInstrAndSampleNames(i);
2521	}
2522		396
2523	// copy over song struct	397	if (instr[i] != NULL)
2524	memcpy(&song, &songTmp, sizeof (songTyp));	398	{
2525	fixSongName();	399	for (int32_t j = 0; j < MAX_SMP_PER_INST; j++)
		400	{
		401	sampleTyp *s = &instr[i]->samp[j];
		402
		403	checkSampleRepeat(s);
		404	if (s->pek != NULL)
		405	fixSample(s); // prepare sample for branchless linear interpolation
		406	}
		407	}
		408	}
2526		409
2527	// we are the owners of the allocated memory ptrs set by the loader thread now	410	// we are the owners of the allocated memory ptrs set by the loader thread now
2528		411
@@ -2555,10 +438,7 @@ static void setupLoadedModule(void) · 26 unmodified lines
2555	editor.timer = song.timer;	438	editor.timer = song.timer;
2556	editor.globalVol = song.globVol;	439	editor.globalVol = song.globVol;
2557		440
2558	if (loadedFormat == FORMAT_XM)	441	setFrqTab(tmpLinearPeriodsFlag);
2559	setFrqTab(linearFreqTable);
2560	else
2561	setFrqTab(false);
2562		442
2563	unlockMixerCallback();	443	unlockMixerCallback();
2564		444
@@ -2639,14 +519,9 @@ bool handleModuleLoadFromArg(int argc, char **argv) · 74 unmodified lines
2639	UNICHAR_CHDIR(editor.binaryPathU);	519	UNICHAR_CHDIR(editor.binaryPathU);
2640		520
2641	const int32_t filesize = getFileSize(filenameU);	521	const int32_t filesize = getFileSize(filenameU);
2642	if (filesize == -1 \|\| filesize >= 512L10241024) // >=2GB or >=512MB	522	if (filesize == -1 \|\| filesize >= 512L10241024) // 1) >=2GB 2) >=512MB
2643	{	523	{
2644	okBox(0, "System message", "Error: The module is too big to be loaded!");	524	okBox(0, "System message", "Error: The module is too big to be loaded!");
2645	/* This is not really true, but let's add this check to prevent accidentally
2646	** passing really big files to the program. And how often do you really
2647	** see a >=512MB .XM/.S3M module?
2648	*/
2649
2650	free(filenameU);	525	free(filenameU);
2651	UNICHAR_CHDIR(tmpPathU); // set old path back	526	UNICHAR_CHDIR(tmpPathU); // set old path back
2652	return false;	527	return false;
@@ -2659,6 +534,64 @@ bool handleModuleLoadFromArg(int argc, char **argv) · 6 unmodified lines
2659	return result;	534	return result;
2660	}	535	}
2661		536
		537	static bool fileIsModule(UNICHAR *pathU)
		538	{
		539	FILE *f = UNICHAR_FOPEN(pathU, "rb");
		540	if (f == NULL)
		541	return false;
		542
		543	int8_t modFormat = detectModule(f);
		544	fclose(f);
		545
		546	/* If the module was not identified (possibly STK type),
		547	** check the file extension and handle it as a module only
		548	** if it starts with "mod."/"stk." or ends with ".mod"/".stk" (case insensitive).
		549	*/
		550	if (modFormat == FORMAT_POSSIBLY_STK)
		551	{
		552	char *path = unicharToCp437(pathU, false);
		553	if (path == NULL)
		554	return false;
		555
		556	int32_t pathLen = (int32_t)strlen(path);
		557
		558	// get filename from path
		559	int32_t i = pathLen;
		560	while (i--)
		561	{
		562	if (path[i] == DIR_DELIMITER)
		563	break;
		564	}
		565
		566	char *filename = path;
		567	if (i > 0)
		568	filename += i + 1;
		569
		570	int32_t filenameLen = (int32_t)strlen(filename);
		571	// --------------------------
		572
		573	if (filenameLen > 5)
		574	{
		575	if (!_strnicmp("mod.", filename, 4) \|\| !_strnicmp("stk.", filename, 4))
		576	{
		577	free(path);
		578	return true;
		579	}
		580
		581	if (!_strnicmp(".mod", &filename[filenameLen-4], 4) \|\| !_strnicmp(".stk", &filename[filenameLen-4], 4))
		582	{
		583	free(path);
		584	return true;
		585	}
		586	}
		587
		588	free(path);
		589	return false;
		590	}
		591
		592	return (modFormat != FORMAT_UNKNOWN);
		593	}
		594
2662	void loadDroppedFile(char *fullPathUTF8, bool songModifiedCheck)	595	void loadDroppedFile(char *fullPathUTF8, bool songModifiedCheck)
2663	{	596	{
2664	if (ui.sysReqShown \|\| fullPathUTF8 == NULL)	597	if (ui.sysReqShown \|\| fullPathUTF8 == NULL)
@@ -2701,15 +634,11 @@ void loadDroppedFile(char *fullPathUTF8, bool songModifiedCheck) · 36 unmodified lines
2701		634
2702	// pass UTF8 to these tests so that we can test file ending in ASCII/ANSI	635	// pass UTF8 to these tests so that we can test file ending in ASCII/ANSI
2703		636
2704	if (fileIsInstrument(fullPathUTF8))	637	if (fileIsInstr(fullPathU))
2705	{	638	{
2706	loadInstr(fullPathU);	639	loadInstr(fullPathU);
2707	}	640	}
2708	else if (fileIsSample(fullPathUTF8))	641	else if (fileIsModule(fullPathU))
2709	{
2710	loadSample(fullPathU, editor.curSmp, false);
2711	}
2712	else
2713	{	642	{
2714	SDL_RestoreWindow(video.window);	643	SDL_RestoreWindow(video.window);
2715		644
@@ -2729,6 +658,10 @@ void loadDroppedFile(char *fullPathUTF8, bool songModifiedCheck) · 13 unmodified lines
2729	editor.loadMusicEvent = EVENT_LOADMUSIC_DRAGNDROP;	658	editor.loadMusicEvent = EVENT_LOADMUSIC_DRAGNDROP;
2730	loadMusic(fullPathU);	659	loadMusic(fullPathU);
2731	}	660	}
		661	else
		662	{
		663	loadSample(fullPathU, editor.curSmp, false);
		664	}
2732		665
2733	free(fullPathU);	666	free(fullPathU);
2734	}	667	}

src/ft2_module_loader.h+14−2

@@ -2,12 +2,24 @@ · 1 unmodified line
2		2
3	#include <stdint.h>	3	#include <stdint.h>
4	#include <stdbool.h>	4	#include <stdbool.h>
		5	#include "ft2_header.h"
5	#include "ft2_unicode.h"	6	#include "ft2_unicode.h"
6		7
		8	bool tmpPatternEmpty(uint16_t nr);
		9	void clearUnusedChannels(tonTyp *p, int16_t pattLen, int32_t antChn);
		10	bool allocateTmpInstr(int16_t nr);
		11	bool allocateTmpPatt(int32_t nr, uint16_t rows);
7	void loadMusic(UNICHAR *filenameU);	12	void loadMusic(UNICHAR *filenameU);
8	bool loadMusicUnthreaded(UNICHAR *filenameU, bool autoPlay);	13	bool loadMusicUnthreaded(UNICHAR *filenameU, bool autoPlay);
9	bool handleModuleLoadFromArg(int argc, char **argv);	14	bool handleModuleLoadFromArg(int argc, char **argv);
10	void loadDroppedFile(char *fullPathUTF8, bool songModifiedCheck);	15	void loadDroppedFile(char *fullPathUTF8, bool songModifiedCheck);
11	void handleLoadMusicEvents(void);	16	void handleLoadMusicEvents(void);
12	void clearUnusedChannels(tonTyp *p, int16_t pattLen, int32_t antChn);	17
13	void checkSampleRepeat(sampleTyp *s);	18	// file extensions accepted by Disk Op. in module mode
		19	extern char *supportedModExtensions[];
		20
		21	extern volatile bool tmpLinearPeriodsFlag;
		22	extern int16_t pattLensTmp[MAX_PATTERNS];
		23	extern tonTyp *pattTmp[MAX_PATTERNS];
		24	extern instrTyp *instrTmp[1+256];
		25	extern songTyp songTmp;

src/ft2_replayer.c+46−102

 ** If something looks to be off, it probably isn't!
 */
-// non-FT2 precalced stuff (these are kinda big...)
+static double dLogTab[768], dExp2MulTab[32];
-static double dPeriod2HzTab[65536], dLogTab[768], dExp2MulTab[32], dHz2MixDeltaMul;
-static uint32_t revMixDeltaTab[65536];
 static bool bxxOverflow;
 static tonTyp nilPatternLine[MAX_VOICES];
 tonTyp *patt[MAX_PATTERNS];
 // ----------------------------------
-void fixSongName(void) // removes spaces from right side of song name
+void fixString(char *str, int32_t lastChrPos) // removes leading spaces and 0x1A chars
 {
-	for (int32_t i = 20; i >= 0; i--)
+	for (int32_t i = lastChrPos; i >= 0; i--)
 	{
-		if (song.name[i] == ' ')
+		if (str[i] == ' ' || str[i] == 0x1A)
-			song.name[i] = '\0';
+			str[i] = '\0';
-		else
+		else if (str[i] != '\0')
 			break;
 	}
+	str[lastChrPos+1] = '\0';
 }
-void fixSampleName(int16_t nr) // removes spaces from right side of ins/smp names
+void fixSongName(void)
 {
-	for (int32_t i = 21; i >= 0; i--)
+	fixString(song.name, 19);
-	{
+}
-		if (song.instrName[nr][i] == ' ')
-			song.instrName[nr][i] = '\0';
-		else
-			break;
-	}
+void fixInstrAndSampleNames(int16_t nr)
+{
+	fixString(song.instrName[nr], 21);
 	if (instr[nr] != NULL)
 	{
 		sampleTyp *s = instr[nr]->samp;
 		for (int32_t i = 0; i < MAX_SMP_PER_INST; i++, s++)
-		{
+			fixString(s->name, 21);
-			for (int16_t j = 21; j >= 0; j--)
-			{
-				if (s->name[j] == ' ')
-					s->name[j] = '\0';
-				else
-					break;
-			}
-			s->name[22] = '\0'; // just in case (for tracker, not present in sample header when saving)
-		}
 	}
 }
 	#define MIN_PERIOD (0)
 	#define MAX_PERIOD (((10*12*16)-1)-1) /* -1 (because of bugged amigaPeriods table values) */
-	double (*dGetHzFromPeriod)(int32_t) = linearPeriodsFlag ? &linearPeriod2Hz : &amigaPeriod2Hz;
+	double (*dGetHzFromPeriod)(int32_t) = linearPeriodsFlag ? dLinearPeriod2Hz : dAmigaPeriod2Hz;
 	const uint16_t *periodTab = linearPeriodsFlag ? linearPeriods : amigaPeriods;
 	if (midCFreq <= 0 || periodTab == NULL)
 	return i+1;
 }
-double linearPeriod2Hz(int32_t period)
+double dLinearPeriod2Hz(int32_t period)
 {
 	if (period == 0)
-		return 0.0; // in FT2, a period of 0 gives 0Hz
+		return 0.0; // in FT2, a period of 0 results in 0Hz
-	const uint16_t invPeriod = (uint16_t)(12 * 192 * 4) - (uint16_t)period; // this intentionally 16-bit-underflows to be accurate to FT2
+	const uint16_t invPeriod = (12 * 192 * 4) - (uint16_t)period; // intentionally underflows (uint16_t) to be FT2-accurate
 	const int32_t quotient = invPeriod / 768;
 	const int32_t remainder = invPeriod % 768;
-	return dLogTab[remainder] * dExp2MulTab[(14-quotient) & 31]; // x = y >> ((14-octave) & 31)
+	return dLogTab[remainder] * dExp2MulTab[(14-quotient) & 31]; // x = y / 2^((14-quotient) & 31)
 }
-double amigaPeriod2Hz(int32_t period)
+double dAmigaPeriod2Hz(int32_t period)
 {
 	if (period == 0)
-		return 0.0; // in FT2, a period of 0 gives 0Hz
+		return 0.0; // in FT2, a period of 0 results in 0Hz
-	return (double)(8363*1712) / period;
+	return (double)(8363 * 1712) / period;
 }
-static void calcPeriod2HzTable(void) // called every time "linear/amiga frequency" mode is changed
+double dPeriod2Hz(int32_t period)
 {
-	if (audio.linearPeriodsFlag)
+	return audio.linearPeriodsFlag ? dLinearPeriod2Hz(period) : dAmigaPeriod2Hz(period);
-	{
-		// linear periods
-		for (int32_t i = 0; i < 65536; i++)
-			dPeriod2HzTab[i] = linearPeriod2Hz(i);
-	}
-	else
-	{
-		// Amiga periods
-		for (int32_t i = 0; i < 65536; i++)
-			dPeriod2HzTab[i] = amigaPeriod2Hz(i);
-	}
 }
-/* Called every time "linear/amiga frequency" mode or audio frequency is changed.
+// returns *exact* FT2 C-4 voice rate (depending on finetune, relative note and linear/Amiga period mode)
-**
-** Used to replace a DIV with a MUL in the outside audio mixer loop. This can actually
-** be beneficial if you are playing VERY tightly looped samples, and/or if the CPU has
-** no DIV instruction (certain ARM CPUs, for instance).
-**
-** A bit hackish and extreme considering it's 65536*4 bytes long, but why not.
-*/
-void calcRevMixDeltaTable(void)
-{
-	for (int32_t i = 0; i < 65536; i++)
-	{
-		const uint16_t period = (uint16_t)i;
-		const uint64_t delta = getMixerDelta(period);
-		uint32_t revDelta = UINT32_MAX;
-		if (delta != 0)
-			revDelta = (uint32_t)((UINT64_MAX / delta) >> 16); // MUST be truncated, not rounded!
-		revMixDeltaTab[i] = revDelta;
-	}
-}
-// returns *exact* FT2 C-4 voice rate (depending on finetune, relative note and Amiga/linear mode)
 double getSampleC4Rate(sampleTyp *s)
 {
 	int32_t note = (96/2) + s->relTon;
 	else
 		note2Period = amigaPeriods;
-	calcPeriod2HzTable();
-	calcRevMixDeltaTable();
 	resumeAudio();
-	// update "frequency table" radiobutton, if it's shown
 	if (ui.configScreenShown && editor.currConfigScreen == CONFIG_SCREEN_IO_DEVICES)
 	{
-		setConfigIORadioButtonStates();
+		// update "frequency table" radiobutton, if it's shown
+		setConfigIORadioButtonStates();
+		// update mid-C freq. in instr. editor (it can slightly differ between Amiga/linear)
 		if (ui.instEditorShown)
 			drawC4Rate();
 	}
 	if (audioFreq <= 0)
 		return;
-	dHz2MixDeltaMul = (double)MIXER_FRAC_SCALE / audioFreq;
+	audio.dHz2MixDeltaMul = (double)MIXER_FRAC_SCALE / audioFreq;
 	audio.quickVolRampSamples = (int32_t)((audioFreq / 200.0) + 0.5); // rounded
 	audio.dRampQuickVolMul = 1.0 / audio.quickVolRampSamples;
 	}
 }
-double dPeriod2Hz(uint16_t period) // uses LUT for fast operation
+int32_t getPianoKey(uint16_t period, int8_t finetune, int8_t relativeNote) // for piano in Instr. Ed.
 {
-	return dPeriod2HzTab[period];
+	assert(note2Period != NULL);
-}
-int64_t getMixerDelta(uint16_t period)
+	if (period > note2Period[0])
-{
+		return -1; // out of lower range on piano
-	/* Precision has been tested for most extreme case (Amiga period 1, 44100Hz),
-	** and there is no precision loss using 64-bit double-precision here, even
-	** though we can get VERY big numbers.
-	*/
-	return (int64_t)((dPeriod2Hz(period) * dHz2MixDeltaMul) + 0.5); // Hz -> rounded 32.32 fixed-point mixer delta
-}
-// used for calculating the max safe amount of samples to mix before entering inner mix loop
+	if (audio.linearPeriodsFlag)
-uint32_t getRevMixerDelta(uint16_t period)
+	{
-{
+		int32_t note = ((10*12*16*4+64) - (period + 16*2)) >> 2;
-	return revMixDeltaTab[period];
+		note -= ((int8_t)finetune >> 3) + 16;
-}
+		note = ((note >> 4) + 1) - relativeNote;
-int32_t getPianoKey(uint16_t period, int8_t finetune, int8_t relativeNote) // for piano in Instr. Ed.
+		return note;
-{
+	}
-	if (period > note2Period[0]) // don't show periods below C-0 (w/ lowest finetune) on piano
-		return -1;
+	/* Amiga periods require a slower method...
+	** This is not 100% accurate for all periods, but should be faster
+	** than using log2() and floating-point arithmetics.
+	*/
 	finetune = ((int8_t)finetune >> 3) + 16;
-	// this is not 100% accurate for all periods, but should be faster than using log2() and floating-point arithmetics
 	int32_t hiPeriod = (10*12*16)+16;
 	int32_t loPeriod = 0;
 			dVol = 1.0;
 		ch->dFinalVol = dVol;
+		ch->finalVol = (uint8_t)(int32_t)((ch->dFinalVol * 255) + 0.5); // 0.0 .. 1.0 -> 0..255 rounded, used for visuals
 	}
 	else
 	{
 		ch->dFinalVol = 0.0;
+		ch->finalVol = 0;
 	}
 	// *** PANNING ENVELOPE ***
 		return false;
 	}
-	calcPeriod2HzTable();
-	calcRevMixDeltaTable();
 	calcPanningTable();
 	setPos(0, 0, true);

src/ft2_replayer.h+30−30

@@ -100,17 +100,6 @@ __attribute__ ((packed)) · 99 unmodified lines
100	#endif	100	#endif
101	songMODInstrHeaderTyp;	101	songMODInstrHeaderTyp;
102		102
103	typedef struct songMOD15HeaderTyp_t
104	{
105	char name[20];
106	songMODInstrHeaderTyp instr[15];
107	uint8_t len, repS, songTab[128];
108	}
109	#ifdef __GNUC__
110	__attribute__ ((packed))
111	#endif
112	songMOD15HeaderTyp;
113
114	typedef struct songMOD31HeaderTyp_t	103	typedef struct songMOD31HeaderTyp_t
115	{	104	{
116	char name[20];	105	char name[20];
@@ -214,11 +203,12 @@ typedef struct stmTyp_t · 97 unmodified lines
214	int16_t midiPitch;	203	int16_t midiPitch;
215	uint16_t outPeriod, realPeriod, finalPeriod, tonTyp, wantPeriod, portaSpeed;	204	uint16_t outPeriod, realPeriod, finalPeriod, tonTyp, wantPeriod, portaSpeed;
216	uint16_t envVCnt, envPCnt, eVibAmp, eVibSweep;	205	uint16_t envVCnt, envPCnt, eVibAmp, eVibSweep;
217	uint16_t fadeOutAmp, fadeOutSpeed, midiVibDepth;	206	uint16_t fadeOutAmp, fadeOutSpeed, midiVibDepth;
218	int32_t envVIPValue, envPIPValue, envVAmp, envPAmp;	207	int32_t envVIPValue, envPIPValue, envVAmp, envPAmp;
219	int32_t oldFinalPeriod, smpStartPos;	208	int32_t oldFinalPeriod, smpStartPos;
220		209
221	double dFinalVol;	210	uint8_t finalVol; // 0..255 (for visuals)
		211	double dFinalVol; // 0.0 .. 1.0 (for mixer)
222		212
223	sampleTyp *smpPtr;	213	sampleTyp *smpPtr;
224	instrTyp *instrPtr;	214	instrTyp *instrPtr;
@@ -241,38 +231,48 @@ typedef struct tonTyp_t · 16 unmodified lines
241	uint8_t ton, instr, vol, effTyp, eff;	231	uint8_t ton, instr, vol, effTyp, eff;
242	} tonTyp;	232	} tonTyp;
243		233
		234	#ifdef _MSC_VER
		235	#pragma pack(push)
		236	#pragma pack(1)
		237	#endif
		238
244	typedef struct syncedChannel_t // used for audio/video sync queue	239	typedef struct syncedChannel_t // used for audio/video sync queue
245	{	240	{
246	bool envSustainActive;	241	uint8_t status;
247	int8_t fineTune, relTonNr;	242	uint8_t pianoNoteNr;
248	uint8_t status, sampleNr, instrNr;	243	uint8_t sampleNr, instrNr;
249	uint16_t finalPeriod;	244	uint16_t smpStartPos;
250	int32_t smpStartPos;	245	uint8_t vol;
251	double dFinalVol;	246	double dHz;
252	} syncedChannel_t;	247	}
		248	#ifdef __GNUC__
		249	__attribute__ ((packed))
		250	#endif
		251	syncedChannel_t;
		252
		253	#ifdef _MSC_VER
		254	#pragma pack(pop)
		255	#endif
253		256
254	double getSampleC4Rate(sampleTyp *s);	257	double getSampleC4Rate(sampleTyp *s);
255		258
256	void setNewSongPos(int32_t pos);	259	void setNewSongPos(int32_t pos);
257	void resetReplayerState(void);	260	void resetReplayerState(void);
258		261
259	void fixSongName(void); // removes spaces from right side of song name	262	void fixString(char *str, int32_t lastChrPos); // removes leading spaces and 0x1A chars
260	void fixSampleName(int16_t nr); // removes spaces from right side of ins/smp names	263	void fixSongName(void);
		264	void fixInstrAndSampleNames(int16_t nr);
		265
261	void calcReplayerVars(int32_t rate);	266	void calcReplayerVars(int32_t rate);
262		267
263	// used on external sample load and during sample loading in some module formats	268	// used on external sample load and during sample loading in some module formats
264	void tuneSample(sampleTyp *s, const int32_t midCFreq, bool linearPeriodsFlag);	269	void tuneSample(sampleTyp *s, const int32_t midCFreq, bool linearPeriodsFlag);
265		270
266	void calcRevMixDeltaTable(void);
267	void calcReplayerLogTab(void);	271	void calcReplayerLogTab(void);
268		272
269	double linearPeriod2Hz(int32_t period);	273	double dLinearPeriod2Hz(int32_t period);
270	double amigaPeriod2Hz(int32_t period);	274	double dAmigaPeriod2Hz(int32_t period);
271		275	double dPeriod2Hz(int32_t period);
272	double dPeriod2Hz(uint16_t period); // uses LUT for fast operation
273
274	int64_t getMixerDelta(uint16_t period);
275	uint32_t getRevMixerDelta(uint16_t period);
276		276
277	int32_t getPianoKey(uint16_t period, int8_t finetune, int8_t relativeNote); // for piano in Instr. Ed.	277	int32_t getPianoKey(uint16_t period, int8_t finetune, int8_t relativeNote); // for piano in Instr. Ed.
278		278

src/ft2_sample_ed.c+45−0

@@ -47,6 +47,37 @@ static SDL_Thread *thread; · 46 unmodified lines
47	// globals	47	// globals
48	int32_t smpEd_Rx1 = 0, smpEd_Rx2 = 0;	48	int32_t smpEd_Rx1 = 0, smpEd_Rx2 = 0;
49		49
		50	// allocs sample with proper alignment and padding for branchless resampling interpolation
		51	bool allocateTmpSmpData(sampleTyp *s, int32_t length)
		52	{
		53	s->origPek = (int8_t *)malloc(length + LOOP_FIX_LEN);
		54	if (s->origPek == NULL)
		55	{
		56	s->pek = NULL;
		57	return false;
		58	}
		59
		60	s->pek = s->origPek + SMP_DAT_OFFSET;
		61	return true;
		62	}
		63
		64	// reallocs sample with proper alignment and padding for branchless resampling interpolation
		65	bool reallocateTmpSmpData(sampleTyp *s, int32_t length)
		66	{
		67	if (s->origPek == NULL)
		68	return allocateTmpSmpData(s, length);
		69
		70	s->origPek = (int8_t *)realloc(s->origPek, length + LOOP_FIX_LEN);
		71	if (s->origPek == NULL)
		72	{
		73	s->pek = NULL;
		74	return false;
		75	}
		76
		77	s->pek = s->origPek + SMP_DAT_OFFSET;
		78	return true;
		79	}
		80
50	sampleTyp *getCurSample(void)	81	sampleTyp *getCurSample(void)
51	{	82	{
52	if (editor.curInstr == 0 \|\| instr[editor.curInstr] == NULL)	83	if (editor.curInstr == 0 \|\| instr[editor.curInstr] == NULL)
@@ -55,6 +86,20 @@ sampleTyp *getCurSample(void) · 2 unmodified lines
55	return &instr[editor.curInstr]->samp[editor.curSmp];	86	return &instr[editor.curInstr]->samp[editor.curSmp];
56	}	87	}
57		88
		89	void checkSampleRepeat(sampleTyp *s)
		90	{
		91	if (s->repS < 0) s->repS = 0;
		92	if (s->repL < 0) s->repL = 0;
		93	if (s->repS > s->len) s->repS = s->len;
		94	if (s->repS+s->repL > s->len) s->repL = s->len - s->repS;
		95
		96	if (s->repL == 0) // non-FT2 fix: disable loop if loop length is 0
		97	{
		98	s->repS = 0;
		99	s->typ &= ~3;
		100	}
		101	}
		102
58	// modifies samples before index 0, and after loop/end (for branchless mixer interpolation (kinda))	103	// modifies samples before index 0, and after loop/end (for branchless mixer interpolation (kinda))
59	void fixSample(sampleTyp *s)	104	void fixSample(sampleTyp *s)
60	{	105	{

src/ft2_sample_ed.h+7−0

 #define SAMPLE_AREA_WIDTH 632
 #define SAMPLE_AREA_Y_CENTER 250
+// allocs sample with proper alignment and padding for branchless resampling interpolation
+bool allocateTmpSmpData(sampleTyp *s, int32_t length);
+// reallocs sample with proper alignment and padding for branchless resampling interpolation
+bool reallocateTmpSmpData(sampleTyp *s, int32_t length);
 sampleTyp *getCurSample(void);
+void checkSampleRepeat(sampleTyp *s);
 void fixSample(sampleTyp *s); // modifies samples before index 0, and after loop/end (for branchless mixer interpolation)
 void restoreSample(sampleTyp *s); // restores samples after loop/end
 void clearSample(void);

src/ft2_sample_loader.c+125−2071

@@ -16,1885 +16,124 @@ · 15 unmodified lines
16	#include "ft2_diskop.h"	16	#include "ft2_diskop.h"
17	#include "ft2_structs.h"	17	#include "ft2_structs.h"
18		18
19	/* All of these routines were written from scratch and were not present	19	bool loadAIFF(FILE *f, uint32_t filesize);
20	** in original FT2.	20	bool loadIFF(FILE *f, uint32_t filesize);
21	*/	21	bool loadRAW(FILE *f, uint32_t filesize);
		22	bool loadWAV(FILE *f, uint32_t filesize);
22		23
23	enum	24	enum
24	{	25	{
25	STEREO_SAMPLE_READ_LEFT = 1,	26	FORMAT_UNKNOWN = 0,
26	STEREO_SAMPLE_READ_RIGHT = 2,	27	FORMAT_IFF = 1,
27	STEREO_SAMPLE_CONVERT = 3,	28	FORMAT_WAV = 2,
28		29	FORMAT_AIFF = 3
29	WAV_FORMAT_PCM = 0x0001,	30	};
30	WAV_FORMAT_IEEE_FLOAT = 0x0003
31	};
32
33	static volatile bool sampleIsLoading;
34	static bool loadAsInstrFlag;
35	static uint8_t sampleSlot;
36	static int16_t stereoSampleLoadMode;
37	static SDL_Thread *thread;
38
39	static void normalize32bitSigned(int32_t *sampleData, uint32_t sampleLength);
40	static void normalize16bitFloatSigned(float *fSampleData, uint32_t sampleLength);
41	static void normalize64bitDoubleSigned(double *dSampleData, uint32_t sampleLength);
42
43	void freeTmpSample(sampleTyp *s)
44	{
45	if (s->origPek != NULL)
46	{
47	free(s->origPek);
48	s->origPek = NULL;
49	s->pek = NULL;
50	}
51
52	memset(s, 0, sizeof (sampleTyp));
53	}
54
55	void removeSampleIsLoadingFlag(void)
56	{
57	sampleIsLoading = false;
58	}
59
60	static int32_t getAIFFRate(uint8_t *in)
61	{
62	int32_t exp = (int32_t)(((in[0] & 0x7F) << 8) \| in[1]);
63	uint32_t lo = (in[2] << 24) \| (in[3] << 16) \| (in[4] << 8) \| in[5];
64	uint32_t hi = (in[6] << 24) \| (in[7] << 16) \| (in[8] << 8) \| in[9];
65
66	if (exp == 0 && lo == 0 && hi == 0)
67	return 0;
68
69	exp -= 16383;
70
71	double dOut = ldexp(lo, -31 + exp) + ldexp(hi, -63 + exp);
72	return (int32_t)(dOut + 0.5); // rounded
73	}
74
75	static bool aiffIsStereo(FILE *f) // only ran on files that are confirmed to be AIFFs
76	{
77	uint16_t numChannels;
78	uint32_t chunkID, chunkSize;
79
80	uint32_t oldPos = ftell(f);
81
82	fseek(f, 0, SEEK_END);
83	int32_t filesize = ftell(f);
84
85	if (filesize < 12)
86	{
87	fseek(f, oldPos, SEEK_SET);
88	return false;
89	}
90
91	fseek(f, 12, SEEK_SET);
92
93	uint32_t commPtr = 0;
94	uint32_t commLen = 0;
95
96	int32_t bytesRead = 0;
97	while (!feof(f) && bytesRead < filesize-12)
98	{
99	fread(&chunkID, 4, 1, f); chunkID = SWAP32(chunkID); if (feof(f)) break;
100	fread(&chunkSize, 4, 1, f); chunkSize = SWAP32(chunkSize); if (feof(f)) break;
101
102	int32_t endOfChunk = (ftell(f) + chunkSize) + (chunkSize & 1);
103	switch (chunkID)
104	{
105	case 0x434F4D4D: // "COMM"
106	{
107	commPtr = ftell(f);
108	commLen = chunkSize;
109	}
110	break;
111
112	default: break;
113	}
114
115	bytesRead += (chunkSize + (chunkSize & 1));
116	fseek(f, endOfChunk, SEEK_SET);
117	}
118
119	if (commPtr == 0 \|\| commLen < 2)
120	{
121	fseek(f, oldPos, SEEK_SET);
122	return false;
123	}
124
125	fseek(f, commPtr, SEEK_SET);
126	fread(&numChannels, 2, 1, f); numChannels = SWAP16(numChannels);
127	fseek(f, oldPos, SEEK_SET);
128
129	return (numChannels == 2);
130	}
131
132	static bool wavIsStereo(FILE *f) // only ran on files that are confirmed to be WAVs
133	{
134	uint16_t numChannels;
135	uint32_t chunkID, chunkSize;
136
137	uint32_t oldPos = ftell(f);
138
139	fseek(f, 0, SEEK_END);
140	int32_t filesize = ftell(f);
141
142	if (filesize < 12)
143	{
144	fseek(f, oldPos, SEEK_SET);
145	return false;
146	}
147
148	fseek(f, 12, SEEK_SET);
149
150	uint32_t fmtPtr = 0;
151	uint32_t fmtLen = 0;
152
153	int32_t bytesRead = 0;
154	while (!feof(f) && bytesRead < filesize-12)
155	{
156	fread(&chunkID, 4, 1, f); if (feof(f)) break;
157	fread(&chunkSize, 4, 1, f); if (feof(f)) break;
158
159	int32_t endOfChunk = (ftell(f) + chunkSize) + (chunkSize & 1);
160	switch (chunkID)
161	{
162	case 0x20746D66: // "fmt "
163	{
164	fmtPtr = ftell(f);
165	fmtLen = chunkSize;
166	}
167	break;
168
169	default: break;
170	}
171
172	bytesRead += (chunkSize + (chunkSize & 1));
173	fseek(f, endOfChunk, SEEK_SET);
174	}
175
176	if (fmtPtr == 0 \|\| fmtLen < 4)
177	{
178	fseek(f, oldPos, SEEK_SET);
179	return false;
180	}
181
182	fseek(f, fmtPtr + 2, SEEK_SET);
183	fread(&numChannels, 2, 1, f);
184	fseek(f, oldPos, SEEK_SET);
185
186	return (numChannels == 2);
187	}
188
189	static int32_t SDLCALL loadAIFFSample(void *ptr)
190	{
191	char compType[4];
192	int8_t *audioDataS8;
193	uint8_t sampleRateBytes[10], *audioDataU8;
194	int16_t audioDataS16, audioDataS16_2, smp16;
195	uint16_t numChannels, bitDepth;
196	int32_t j, smp32, *audioDataS32;
197	uint32_t i, blockName, blockSize;
198	uint32_t offset, len32;
199	int64_t smp64;
200	sampleTyp tmpSmp;
201
202	// this is important for the "goto" on load error
203	FILE *f = NULL;
204	memset(&tmpSmp, 0, sizeof (tmpSmp));
205
206	if (editor.tmpFilenameU == NULL)
207	{
208	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
209	goto aiffLoadError;
210	}
211
212	UNICHAR *filename = editor.tmpFilenameU;
213
214	f = UNICHAR_FOPEN(filename, "rb");
215	if (f == NULL)
216	{
217	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
218	goto aiffLoadError;
219	}
220
221	fseek(f, 0, SEEK_END);
222	int32_t filesize = ftell(f);
223	if (filesize < 12)
224	{
225	okBoxThreadSafe(0, "System message", "Error loading sample: The sample is not supported or is invalid!");
226	goto aiffLoadError;
227	}
228
229	// handle chunks
230
231	uint32_t commPtr = 0;
232	uint32_t commLen = 0;
233	uint32_t ssndPtr = 0;
234	uint32_t ssndLen = 0;
235
236	fseek(f, 12, SEEK_SET);
237	while (!feof(f) && ftell(f) < filesize-12)
238	{
239	fread(&blockName, 4, 1, f); if (feof(f)) break;
240	fread(&blockSize, 4, 1, f); if (feof(f)) break;
241
242	blockName = SWAP32(blockName);
243	blockSize = SWAP32(blockSize);
244
245	switch (blockName)
246	{
247	case 0x434F4D4D: // "COMM"
248	{
249	commPtr = ftell(f);
250	commLen = blockSize;
251	}
252	break;
253
254	case 0x53534E44: // "SSND"
255	{
256	ssndPtr = ftell(f);
257	ssndLen = blockSize;
258	}
259	break;
260
261	default: break;
262	}
263
264	fseek(f, blockSize + (blockSize & 1), SEEK_CUR);
265	}
266
267	if (commPtr == 0 \|\| commLen < 18 \|\| ssndPtr == 0)
268	{
269	okBoxThreadSafe(0, "System message", "Error loading sample: The sample is not supported or is invalid!");
270	goto aiffLoadError;
271	}
272
273	// kludge for some really strange AIFFs
274	if (ssndLen == 0)
275	ssndLen = filesize - ssndPtr;
276
277	if (ssndPtr+ssndLen > (uint32_t)filesize)
278	ssndLen = filesize - ssndPtr;
279
280	fseek(f, commPtr, SEEK_SET);
281	fread(&numChannels, 2, 1, f); numChannels = SWAP16(numChannels);
282	fseek(f, 4, SEEK_CUR);
283	fread(&bitDepth, 2, 1, f); bitDepth = SWAP16(bitDepth);
284	fread(sampleRateBytes, 1, 10, f);
285
286	if (numChannels != 1 && numChannels != 2)
287	{
288	okBoxThreadSafe(0, "System message", "Error loading sample: Unsupported amounts of channels!");
289	goto aiffLoadError;
290	}
291
292	if (bitDepth != 8 && bitDepth != 16 && bitDepth != 24 && bitDepth != 32)
293	{
294	okBoxThreadSafe(0, "System message", "Error loading sample: Unsupported bitdepth!");
295	goto aiffLoadError;
296	}
297
298	// read compression type (if present)
299	if (commLen > 18)
300	{
301	fread(&compType, 1, 4, f);
302	if (memcmp(compType, "NONE", 4))
303	{
304	okBoxThreadSafe(0, "System message", "Error loading sample: The sample is not supported or is invalid!");
305	goto aiffLoadError;
306	}
307	}
308
309	uint32_t sampleRate = getAIFFRate(sampleRateBytes);
310
311	// sample data chunk
312
313	fseek(f, ssndPtr, SEEK_SET);
314
315	fread(&offset, 4, 1, f);
316	if (offset > 0)
317	{
318	okBoxThreadSafe(0, "System message", "Error loading sample: The sample is not supported or is invalid!");
319	goto aiffLoadError;
320	}
321
322	fseek(f, 4, SEEK_CUR);
323
324	ssndLen -= 8; // don't include offset and blockSize datas
325
326	uint32_t sampleLength = ssndLen;
327	if (sampleLength > MAX_SAMPLE_LEN)
328	sampleLength = MAX_SAMPLE_LEN;
329
330	freeTmpSample(&tmpSmp);
331
332	// read sample data
333
334	if (bitDepth == 8)
335	{
336	// 8-BIT SIGNED PCM
337
338	tmpSmp.origPek = (int8_t *)malloc(sampleLength + LOOP_FIX_LEN);
339	if (tmpSmp.origPek == NULL)
340	{
341	okBoxThreadSafe(0, "System message", "Not enough memory!");
342	goto aiffLoadError;
343	}
344
345	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;
346
347	if (fread(tmpSmp.pek, sampleLength, 1, f) != 1)
348	{
349	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
350	goto aiffLoadError;
351	}
352
353	audioDataS8 = (int8_t *)tmpSmp.pek;
354
355	// stereo conversion
356	if (numChannels == 2)
357	{
358	sampleLength /= 2;
359
360	switch (stereoSampleLoadMode)
361	{
362	case STEREO_SAMPLE_READ_LEFT:
363	{
364	for (i = 1; i < sampleLength; i++)
365	audioDataS8[i] = audioDataS8[(i * 2) + 0];
366	}
367	break;
368
369	case STEREO_SAMPLE_READ_RIGHT:
370	{
371	len32 = sampleLength - 1;
372	for (i = 0; i < len32; i++)
373	audioDataS8[i] = audioDataS8[(i * 2) + 1];
374
375	audioDataS8[i] = 0;
376	}
377	break;
378
379	default:
380	case STEREO_SAMPLE_CONVERT:
381	{
382	len32 = sampleLength - 1;
383	for (i = 0; i < len32; i++)
384	{
385	smp16 = (audioDataS8[(i * 2) + 0] + audioDataS8[(i * 2) + 1]) >> 1;
386	audioDataS8[i] = (int8_t)smp16;
387	}
388
389	audioDataS8[i] = 0;
390	}
391	break;
392	}
393	}
394	}
395	else if (bitDepth == 16)
396	{
397	// 16-BIT SIGNED PCM
398
399	sampleLength /= 2;
400
401	tmpSmp.origPek = (int8_t )malloc((sampleLength 2) + LOOP_FIX_LEN);
402	if (tmpSmp.origPek == NULL)
403	{
404	okBoxThreadSafe(0, "System message", "Not enough memory!");
405	goto aiffLoadError;
406	}
407
408	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;
409
410	if (fread(tmpSmp.pek, sampleLength, 2, f) != 2)
411	{
412	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
413	goto aiffLoadError;
414	}
415
416	// fix endianness
417	audioDataS16 = (int16_t *)tmpSmp.pek;
418	for (i = 0; i < sampleLength; i++)
419	audioDataS16[i] = SWAP16(audioDataS16[i]);
420
421	// stereo conversion
422	if (numChannels == 2)
423	{
424	sampleLength /= 2;
425
426	switch (stereoSampleLoadMode)
427	{
428	case STEREO_SAMPLE_READ_LEFT:
429	{
430	for (i = 1; i < sampleLength; i++)
431	audioDataS16[i] = audioDataS16[(i * 2) + 0];
432	}
433	break;
434
435	case STEREO_SAMPLE_READ_RIGHT:
436	{
437	len32 = sampleLength - 1;
438	for (i = 0; i < len32; i++)
439	audioDataS16[i] = audioDataS16[(i * 2) + 1];
440
441	audioDataS16[i] = 0;
442	}
443	break;
444
445	default:
446	case STEREO_SAMPLE_CONVERT:
447	{
448	len32 = sampleLength - 1;
449	for (i = 0; i < len32; i++)
450	{
451	smp32 = (audioDataS16[(i * 2) + 0] + audioDataS16[(i * 2) + 1]) >> 1;
452	audioDataS16[i] = (int16_t)smp32;
453	}
454
455	audioDataS16[i] = 0;
456	}
457	break;
458	}
459	}
460
461	sampleLength *= 2;
462	tmpSmp.typ \|= 16;
463	}
464	else if (bitDepth == 24)
465	{
466	// 24-BIT SIGNED PCM
467
468	sampleLength /= 3;
469
470	tmpSmp.origPek = (int8_t )malloc(((sampleLength 4) * 2) + LOOP_FIX_LEN);
471	if (tmpSmp.origPek == NULL)
472	{
473	okBoxThreadSafe(0, "System message", "Not enough memory!");
474	goto aiffLoadError;
475	}
476
477	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;
478
479	if (fread(&tmpSmp.pek[sampleLength], sampleLength, 3, f) != 3)
480	{
481	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
482	goto aiffLoadError;
483	}
484
485	audioDataS32 = (int32_t *)tmpSmp.pek;
486
487	// convert to 32-bit
488	audioDataU8 = (uint8_t *)tmpSmp.pek + sampleLength;
489	for (i = 0; i < sampleLength; i++)
490	{
491	audioDataS32[i] = (audioDataU8[0] << 24) \| (audioDataU8[1] << 16) \| (audioDataU8[2] << 8);
492	audioDataU8 += 3;
493	}
494
495	// stereo conversion
496	if (numChannels == 2)
497	{
498	sampleLength /= 2;
499
500	switch (stereoSampleLoadMode)
501	{
502	case STEREO_SAMPLE_READ_LEFT:
503	{
504	for (i = 1; i < sampleLength; i++)
505	audioDataS32[i] = audioDataS32[(i * 2) + 0];
506	}
507	break;
508
509	case STEREO_SAMPLE_READ_RIGHT:
510	{
511	len32 = sampleLength - 1;
512	for (i = 0; i < len32; i++)
513	audioDataS32[i] = audioDataS32[(i * 2) + 1];
514
515	audioDataS32[i] = 0;
516	}
517	break;
518
519	default:
520	case STEREO_SAMPLE_CONVERT:
521	{
522	len32 = sampleLength - 1;
523	for (i = 0; i < len32; i++)
524	{
525	smp64 = audioDataS32[(i * 2) + 0];
526	smp64 += audioDataS32[(i * 2) + 1];
527	smp64 >>= 1;
528
529	audioDataS32[i] = (int32_t)smp64;
530	}
531
532	audioDataS32[i] = 0;
533	}
534	break;
535	}
536	}
537
538	normalize32bitSigned(audioDataS32, sampleLength);
539
540	// downscale to 16-bit (ultra fast method!)
541
542	audioDataS16 = (int16_t *)tmpSmp.pek;
543	audioDataS16_2 = (int16_t *)tmpSmp.pek + 1;
544
545	for (i = 0; i < sampleLength; i++)
546	{
547	audioDataS16[i] = audioDataS16_2[i];
548	audioDataS16_2++;
549	}
550
551	sampleLength *= 2;
552	tmpSmp.typ \|= 16;
553	}
554	else if (bitDepth == 32)
555	{
556	// 32-BIT SIGNED PCM
557
558	sampleLength /= 4;
559
560	tmpSmp.origPek = (int8_t )malloc((sampleLength 4) + LOOP_FIX_LEN);
561	if (tmpSmp.origPek == NULL)
562	{
563	okBoxThreadSafe(0, "System message", "Not enough memory!");
564	goto aiffLoadError;
565	}
566
567	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;
568
569	if (fread(tmpSmp.pek, sampleLength, 4, f) != 4)
570	{
571	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
572	goto aiffLoadError;
573	}
574
575	// fix endianness
576	audioDataS32 = (int32_t *)tmpSmp.pek;
577	for (i = 0; i < sampleLength; i++)
578	audioDataS32[i] = SWAP32(audioDataS32[i]);
579
580	// stereo conversion
581	if (numChannels == 2)
582	{
583	sampleLength /= 2;
584
585	switch (stereoSampleLoadMode)
586	{
587	case STEREO_SAMPLE_READ_LEFT:
588	{
589	for (i = 1; i < sampleLength; i++)
590	audioDataS32[i] = audioDataS32[(i * 2) + 0];
591	}
592	break;
593
594	case STEREO_SAMPLE_READ_RIGHT:
595	{
596	len32 = sampleLength - 1;
597	for (i = 0; i < len32; i++)
598	audioDataS32[i] = audioDataS32[(i * 2) + 1];
599
600	audioDataS32[i] = 0;
601	}
602	break;
603
604	default:
605	case STEREO_SAMPLE_CONVERT:
606	{
607	len32 = sampleLength - 1;
608	for (i = 0; i < len32; i++)
609	{
610	smp64 = audioDataS32[(i * 2) + 0];
611	smp64 += audioDataS32[(i * 2) + 1];
612	smp64 >>= 1;
613
614	audioDataS32[i] = (int32_t)smp64;
615	}
616
617	audioDataS32[i] = 0;
618	}
619	break;
620	}
621	}
622
623	normalize32bitSigned(audioDataS32, sampleLength);
624
625	// downscale to 16-bit (ultra fast method!)
626
627	audioDataS16 = (int16_t *)tmpSmp.pek;
628	audioDataS16_2 = (int16_t *)tmpSmp.pek + 1;
629
630	for (i = 0; i < sampleLength; i++)
631	{
632	audioDataS16[i] = audioDataS16_2[i];
633	audioDataS16_2++;
634	}
635
636	sampleLength *= 2;
637	tmpSmp.typ \|= 16;
638	}
639
640	// adjust memory needed
641	int8_t newPtr = (int8_t )realloc(tmpSmp.origPek, sampleLength + LOOP_FIX_LEN);
642	if (newPtr != NULL)
643	{
644	tmpSmp.origPek = newPtr;
645	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;
646	}
647
648	// set sample attributes
649	tmpSmp.len = sampleLength;
650	tmpSmp.vol = 64;
651	tmpSmp.pan = 128;
652
653	tuneSample(&tmpSmp, sampleRate, audio.linearPeriodsFlag);
654
655	// set sample name
656	char *tmpFilename = unicharToCp437(filename, true);
657	if (tmpFilename != NULL)
658	{
659	j = (int32_t)strlen(tmpFilename);
660	while (j--)
661	{
662	if (tmpFilename[j] == DIR_DELIMITER)
663	break;
664	}
665
666	char *tmpPtr = tmpFilename;
667	if (j > 0)
668	tmpPtr += j + 1;
669
670	sanitizeFilename(tmpPtr);
671
672	uint32_t filenameLen = (uint32_t)strlen(tmpPtr);
673	for (i = 0; i < 22; i++)
674	{
675	if (i < filenameLen)
676	tmpSmp.name[i] = tmpPtr[i];
677	else
678	tmpSmp.name[i] = '\0';
679	}
680
681	free(tmpFilename);
682	}
683
684	fclose(f);
685
686	lockMixerCallback();
687	if (loadAsInstrFlag) // if loaded in instrument mode
688	{
689	freeInstr(editor.curInstr);
690	memset(song.instrName[editor.curInstr], 0, 23);
691	}
692
693	if (instr[editor.curInstr] == NULL)
694	allocateInstr(editor.curInstr);
695
696	if (instr[editor.curInstr] != NULL)
697	{
698	sampleTyp *s = &instr[editor.curInstr]->samp[sampleSlot];
699
700	freeSample(editor.curInstr, sampleSlot);
701	memcpy(s, &tmpSmp, sizeof (sampleTyp));
702	fixSample(s);
703	}
704	else
705	{
706	okBoxThreadSafe(0, "System message", "Not enough memory!");
707	goto aiffLoadError;
708	}
709	unlockMixerCallback();
710
711	fixSampleName(editor.curInstr);
712	setSongModifiedFlag();
713	stereoSampleLoadMode = -1;
714
715	// also sets mouse busy to false when done
716	editor.updateCurSmp = true;
717
718	return true;
719
720	aiffLoadError:
721	if (f != NULL) fclose(f);
722	if (tmpSmp.origPek != NULL) free(tmpSmp.origPek);
723
724	stereoSampleLoadMode = -1;
725	sampleIsLoading = false;
726
727	return false;
728
729	(void)ptr;
730	}
731
732	static int32_t SDLCALL loadIFFSample(void *ptr)
733	{
734	char hdr[4+1];
735	uint8_t i;
736	int32_t j;
737	uint32_t blockName, blockSize;
738	sampleTyp tmpSmp;
739
740	// this is important for the "goto" on load error
741	FILE *f = NULL;
742	memset(&tmpSmp, 0, sizeof (tmpSmp));
743
744	if (editor.tmpFilenameU == NULL)
745	{
746	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
747	goto iffLoadError;
748	}
749
750	UNICHAR *filename = editor.tmpFilenameU;
751
752	f = UNICHAR_FOPEN(filename, "rb");
753	if (f == NULL)
754	{
755	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
756	goto iffLoadError;
757	}
758
759	fseek(f, 0, SEEK_END);
760	int32_t filesize = ftell(f);
761	if (filesize < 12)
762	{
763	okBoxThreadSafe(0, "System message", "Error loading sample: The sample is not supported or is invalid!");
764	goto iffLoadError;
765	}
766
767	fseek(f, 8, SEEK_SET);
768	fread(hdr, 1, 4, f);
769	hdr[4] = '\0';
770	bool is16Bit = !strncmp(hdr, "16SV", 4);
771
772	uint32_t sampleLength = 0;
773	uint32_t sampleVol = 64;
774	uint32_t sampleLoopStart = 0;
775	uint32_t sampleLoopLength = 0;
776	uint16_t sampleRate = 16726;
777
778	uint32_t vhdrPtr = 0;
779	uint32_t vhdrLen = 0;
780	uint32_t bodyPtr = 0;
781	uint32_t bodyLen = 0;
782	uint32_t namePtr = 0;
783	uint32_t nameLen = 0;
784
785	fseek(f, 12, SEEK_SET);
786	while (!feof(f) && ftell(f) < filesize-12)
787	{
788	fread(&blockName, 4, 1, f); if (feof(f)) break;
789	fread(&blockSize, 4, 1, f); if (feof(f)) break;
790
791	blockName = SWAP32(blockName);
792	blockSize = SWAP32(blockSize);
793
794	switch (blockName)
795	{
796	case 0x56484452: // VHDR
797	{
798	vhdrPtr = ftell(f);
799	vhdrLen = blockSize;
800	}
801	break;
802
803	case 0x4E414D45: // NAME
804	{
805	namePtr = ftell(f);
806	nameLen = blockSize;
807	}
808	break;
809
810	case 0x424F4459: // BODY
811	{
812	bodyPtr = ftell(f);
813	bodyLen = blockSize;
814	}
815	break;
816
817	default: break;
818	}
819
820	fseek(f, blockSize + (blockSize & 1), SEEK_CUR);
821	}
822
823	if (vhdrPtr == 0 \|\| vhdrLen < 20 \|\| bodyPtr == 0)
824	{
825	okBoxThreadSafe(0, "System message", "Error loading sample: The sample is not supported or is invalid!");
826	goto iffLoadError;
827	}
828
829	// kludge for some really strange IFFs
830	if (bodyLen == 0)
831	bodyLen = filesize - bodyPtr;
832
833	if (bodyPtr+bodyLen > (uint32_t)filesize)
834	bodyLen = filesize - bodyPtr;
835
836	fseek(f, vhdrPtr, SEEK_SET);
837	fread(&sampleLoopStart, 4, 1, f); sampleLoopStart = SWAP32(sampleLoopStart);
838	fread(&sampleLoopLength, 4, 1, f); sampleLoopLength = SWAP32(sampleLoopLength);
839	fseek(f, 4, SEEK_CUR);
840	fread(&sampleRate, 2, 1, f); sampleRate = SWAP16(sampleRate);
841	fseek(f, 1, SEEK_CUR);
842
843	if (fgetc(f) != 0) // sample type
844	{
845	okBoxThreadSafe(0, "System message", "Error loading sample: The sample is not supported!");
846	goto iffLoadError;
847	}
848
849	fread(&sampleVol, 4, 1, f); sampleVol = SWAP32(sampleVol);
850	if (sampleVol > 65535)
851	sampleVol = 65535;
852
853	sampleVol = (int32_t)((sampleVol / 1024.0) + 0.5);
854	if (sampleVol > 64)
855	sampleVol = 64;
856
857	sampleLength = bodyLen;
858	if (sampleLength > MAX_SAMPLE_LEN)
859	sampleLength = MAX_SAMPLE_LEN;
860
861	if (sampleLoopStart >= MAX_SAMPLE_LEN \|\| sampleLoopLength > MAX_SAMPLE_LEN)
862	{
863	sampleLoopStart = 0;
864	sampleLoopLength = 0;
865	}
866
867	if (sampleLoopStart+sampleLoopLength > sampleLength)
868	{
869	sampleLoopStart = 0;
870	sampleLoopLength = 0;
871	}
872
873	if (sampleLoopStart > sampleLength-2)
874	{
875	sampleLoopStart = 0;
876	sampleLoopLength = 0;
877	}
878
879	tmpSmp.pan = 128;
880	tmpSmp.vol = 64;
881
882	tmpSmp.origPek = (int8_t *)malloc(sampleLength + LOOP_FIX_LEN);
883	if (tmpSmp.origPek == NULL)
884	{
885	okBoxThreadSafe(0, "System message", "Not enough memory!");
886	goto iffLoadError;
887	}
888
889	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;
890
891	fseek(f, bodyPtr, SEEK_SET);
892	if (fread(tmpSmp.pek, sampleLength, 1, f) != 1)
893	{
894	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
895	goto iffLoadError;
896	}
897
898	// set sample attributes
899	tmpSmp.len = sampleLength;
900
901	if (sampleLoopLength > 2)
902	{
903	tmpSmp.repS = sampleLoopStart;
904	tmpSmp.repL = sampleLoopLength;
905	tmpSmp.typ \|= 1;
906	}
907
908	if (is16Bit)
909	{
910	tmpSmp.len &= 0xFFFFFFFE;
911	tmpSmp.repS &= 0xFFFFFFFE;
912	tmpSmp.repL &= 0xFFFFFFFE;
913	tmpSmp.typ \|= 16;
914	}
915
916	tmpSmp.vol = (uint8_t)sampleVol;
917	tmpSmp.pan = 128;
918
919	tuneSample(&tmpSmp, sampleRate, audio.linearPeriodsFlag);
920
921	// set name
922	if (namePtr != 0 && nameLen > 0)
923	{
924	fseek(f, namePtr, SEEK_SET);
925	if (nameLen > 21)
926	{
927	tmpSmp.name[21] = '\0';
928	fread(tmpSmp.name, 1, 21, f);
929	}
930	else
931	{
932	memset(tmpSmp.name, 0, 22);
933	fread(tmpSmp.name, 1, nameLen, f);
934	}
935	}
936	else
937	{
938	// set sample name from filename if we didn't load name from .wav
939	char *tmpFilename = unicharToCp437(filename, true);
940	if (tmpFilename != NULL)
941	{
942	j = (int32_t)strlen(tmpFilename);
943	while (j--)
944	{
945	if (tmpFilename[j] == DIR_DELIMITER)
946	break;
947	}
948
949	char *tmpPtr = tmpFilename;
950	if (j > 0)
951	tmpPtr += j + 1;
952
953	sanitizeFilename(tmpPtr);
954
955	uint32_t filenameLen = (uint32_t)strlen(tmpPtr);
956	for (i = 0; i < 22; i++)
957	{
958	if (i < filenameLen)
959	tmpSmp.name[i] = tmpPtr[i];
960	else
961	tmpSmp.name[i] = '\0';
962	}
963
964	free(tmpFilename);
965	}
966	}
967
968	fclose(f);
969
970	lockMixerCallback();
971	if (loadAsInstrFlag) // if loaded in instrument mode
972	{
973	freeInstr(editor.curInstr);
974	memset(song.instrName[editor.curInstr], 0, 23);
975	}
976
977	if (instr[editor.curInstr] == NULL)
978	allocateInstr(editor.curInstr);
979
980	if (instr[editor.curInstr] != NULL)
981	{
982	sampleTyp *s = &instr[editor.curInstr]->samp[sampleSlot];
983
984	freeSample(editor.curInstr, sampleSlot);
985	memcpy(s, &tmpSmp, sizeof (sampleTyp));
986	fixSample(s);
987	}
988	else
989	{
990	okBoxThreadSafe(0, "System message", "Not enough memory!");
991	goto iffLoadError;
992	}
993	unlockMixerCallback();
994
995	fixSampleName(editor.curInstr);
996	setSongModifiedFlag();
997	stereoSampleLoadMode = -1;
998
999	// also sets mouse busy to false when done
1000	editor.updateCurSmp = true;
1001
1002	return true;
1003
1004	iffLoadError:
1005	if (f != NULL) fclose(f);
1006	if (tmpSmp.origPek != NULL) free(tmpSmp.origPek);
1007
1008	stereoSampleLoadMode = -1;
1009	sampleIsLoading = false;
1010
1011	return false;
1012
1013	(void)ptr;
1014	}
1015
1016	static int32_t SDLCALL loadRawSample(void *ptr)
1017	{
1018	int32_t j;
1019	uint32_t i;
1020	sampleTyp tmpSmp;
1021
1022	// this is important for the "goto" on load error
1023	FILE *f = NULL;
1024	memset(&tmpSmp, 0, sizeof (tmpSmp));
1025
1026	if (editor.tmpFilenameU == NULL)
1027	{
1028	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
1029	goto rawLoadError;
1030	}
1031
1032	UNICHAR *filename = editor.tmpFilenameU;
1033
1034	f = UNICHAR_FOPEN(filename, "rb");
1035	if (f == NULL)
1036	{
1037	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
1038	goto rawLoadError;
1039	}
1040
1041	fseek(f, 0, SEEK_END);
1042	uint32_t filesize = ftell(f);
1043	rewind(f);
1044
1045	if (filesize > MAX_SAMPLE_LEN)
1046	filesize = MAX_SAMPLE_LEN;
1047
1048	if (filesize == 0)
1049	{
1050	okBoxThreadSafe(0, "System message", "Error loading sample: The sample is not supported or is invalid!");
1051	goto rawLoadError;
1052	}
1053
1054	tmpSmp.pan = 128;
1055	tmpSmp.vol = 64;
1056
1057	tmpSmp.origPek = (int8_t *)malloc(filesize + LOOP_FIX_LEN);
1058	if (tmpSmp.origPek == NULL)
1059	{
1060	okBoxThreadSafe(0, "System message", "Not enough memory!");
1061	goto rawLoadError;
1062	}
1063
1064	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;
1065
1066	if (fread(tmpSmp.pek, filesize, 1, f) != 1)
1067	{
1068	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
1069	goto rawLoadError;
1070	}
1071
1072	fclose(f);
1073
1074	char *tmpFilename = unicharToCp437(filename, true);
1075	if (tmpFilename != NULL)
1076	{
1077	j = (int32_t)strlen(tmpFilename);
1078	while (j--)
1079	{
1080	if (tmpFilename[j] == DIR_DELIMITER)
1081	break;
1082	}
1083
1084	char *tmpPtr = tmpFilename;
1085	if (j > 0)
1086	tmpPtr += j + 1;
1087
1088	sanitizeFilename(tmpPtr);
1089
1090	uint32_t filenameLen = (uint32_t)strlen(tmpPtr);
1091	for (i = 0; i < 22; i++)
1092	{
1093	if (i < filenameLen)
1094	tmpSmp.name[i] = tmpPtr[i];
1095	else
1096	tmpSmp.name[i] = '\0';
1097	}
1098
1099	free(tmpFilename);
1100	}
1101
1102	tmpSmp.len = filesize;
1103	tmpSmp.vol = 64;
1104	tmpSmp.pan = 128;
1105
1106	lockMixerCallback();
1107	if (loadAsInstrFlag) // if loaded in instrument mode
1108	{
1109	freeInstr(editor.curInstr);
1110	memset(song.instrName[editor.curInstr], 0, 23);
1111	}
1112
1113	if (instr[editor.curInstr] == NULL)
1114	allocateInstr(editor.curInstr);
1115
1116	if (instr[editor.curInstr] != NULL)
1117	{
1118	sampleTyp *s = &instr[editor.curInstr]->samp[sampleSlot];
1119
1120	freeSample(editor.curInstr, sampleSlot);
1121	memcpy(s, &tmpSmp, sizeof (sampleTyp));
1122	fixSample(s);
1123	}
1124	else
1125	{
1126	okBoxThreadSafe(0, "System message", "Not enough memory!");
1127	goto rawLoadError;
1128	}
1129	unlockMixerCallback();
1130
1131	fixSampleName(editor.curInstr);
1132	setSongModifiedFlag();
1133	stereoSampleLoadMode = -1;
1134
1135	// also sets mouse busy to false when done
1136	editor.updateCurSmp = true;
1137
1138	return true;
1139
1140	rawLoadError:
1141	if (f != NULL) fclose(f);
1142	if (tmpSmp.origPek != NULL) free(tmpSmp.origPek);
1143
1144	stereoSampleLoadMode = -1;
1145	sampleIsLoading = false;
1146
1147	return false;
1148
1149	(void)ptr;
1150	}
1151
1152	static int32_t SDLCALL loadWAVSample(void *ptr)
1153	{
1154	char chr, tmpFilename, tmpPtr;
1155	int8_t *newPtr;
1156	uint8_t *audioDataU8;
1157	int16_t audioDataS16, audioDataS16_2, *ptr16;
1158	uint16_t audioFormat, numChannels, bitsPerSample, tempPan, tempVol;
1159	int32_t j, *audioDataS32, smp32;
1160	uint32_t filenameLen, i, sampleRate, chunkID, chunkSize, sampleLength, filesize;
1161	uint32_t numLoops, loopType, loopStart, loopEnd, bytesRead, endOfChunk, dataPtr, dataLen, fmtPtr;
1162	uint32_t fmtLen, inamPtr, inamLen, smplPtr, smplLen, xtraPtr, xtraLen, xtraFlags, len32;
1163	int64_t smp64;
1164	float *fAudioDataFloat;
1165	double *dAudioDataDouble;
1166	sampleTyp tmpSmp, *s;
1167
1168	// this is important for the "goto" on load error
1169	FILE *f = NULL;
1170	memset(&tmpSmp, 0, sizeof (tmpSmp));
1171
1172	// zero out chunk pointers and lengths
1173	fmtPtr = 0; fmtLen = 0;
1174	dataPtr = 0; dataLen = 0;
1175	inamPtr = 0; inamLen = 0;
1176	xtraPtr = 0; xtraLen = 0;
1177	smplPtr = 0; smplLen = 0;
1178
1179	if (editor.tmpFilenameU == NULL)
1180	{
1181	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
1182	goto wavLoadError;
1183	}
1184
1185	UNICHAR *filename = editor.tmpFilenameU;
1186
1187	f = UNICHAR_FOPEN(filename, "rb");
1188	if (f == NULL)
1189	{
1190	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
1191	goto wavLoadError;
1192	}
1193
1194	// get and check filesize
1195	fseek(f, 0, SEEK_END);
1196	filesize = ftell(f);
1197	if (filesize < 12)
1198	{
1199	okBoxThreadSafe(0, "System message", "Error loading sample: The sample is not supported or is invalid!");
1200	goto wavLoadError;
1201	}
1202
1203	// look for wanted chunks and set up pointers + lengths
1204	fseek(f, 12, SEEK_SET);
1205
1206	bytesRead = 0;
1207	while (!feof(f) && bytesRead < filesize-12)
1208	{
1209	fread(&chunkID, 4, 1, f); if (feof(f)) break;
1210	fread(&chunkSize, 4, 1, f); if (feof(f)) break;
1211
1212	endOfChunk = (ftell(f) + chunkSize) + (chunkSize & 1);
1213	switch (chunkID)
1214	{
1215	case 0x20746D66: // "fmt "
1216	{
1217	fmtPtr = ftell(f);
1218	fmtLen = chunkSize;
1219	}
1220	break;
1221
1222	case 0x61746164: // "data"
1223	{
1224	dataPtr = ftell(f);
1225	dataLen = chunkSize;
1226	}
1227	break;
1228
1229	case 0x5453494C: // "LIST"
1230	{
1231	if (chunkSize >= 4)
1232	{
1233	fread(&chunkID, 4, 1, f);
1234	if (chunkID == 0x4F464E49) // "INFO"
1235	{
1236	bytesRead = 0;
1237	while (!feof(f) && bytesRead < chunkSize)
1238	{
1239	fread(&chunkID, 4, 1, f);
1240	fread(&chunkSize, 4, 1, f);
1241
1242	switch (chunkID)
1243	{
1244	case 0x4D414E49: // "INAM"
1245	{
1246	inamPtr = ftell(f);
1247	inamLen = chunkSize;
1248	}
1249	break;
1250
1251	default: break;
1252	}
1253
1254	bytesRead += (chunkSize + (chunkSize & 1));
1255	}
1256	}
1257	}
1258	}
1259	break;
1260
1261	case 0x61727478: // "xtra"
1262	{
1263	xtraPtr = ftell(f);
1264	xtraLen = chunkSize;
1265	}
1266	break;
1267
1268	case 0x6C706D73: // "smpl"
1269	{
1270	smplPtr = ftell(f);
1271	smplLen = chunkSize;
1272	}
1273	break;
1274
1275	default: break;
1276	}
1277
1278	bytesRead += (chunkSize + (chunkSize & 1));
1279	fseek(f, endOfChunk, SEEK_SET);
1280	}
1281
1282	// we need at least "fmt " and "data" - check if we found them sanely
1283	if ((fmtPtr == 0 \|\| fmtLen < 16) \|\| (dataPtr == 0 \|\| dataLen == 0))
1284	{
1285	okBoxThreadSafe(0, "System message", "Error loading sample: The sample is not supported or is invalid!");
1286	goto wavLoadError;
1287	}
1288
1289	// ---- READ "fmt " CHUNK ----
1290	fseek(f, fmtPtr, SEEK_SET);
1291	fread(&audioFormat, 2, 1, f);
1292	fread(&numChannels, 2, 1, f);
1293	fread(&sampleRate, 4, 1, f);
1294	fseek(f, 6, SEEK_CUR); // unneeded
1295	fread(&bitsPerSample, 2, 1, f);
1296	sampleLength = dataLen;
1297	// ---------------------------
1298
1299	// test if the WAV is compatible with our loader
1300
1301	if (sampleRate == 0 \|\| sampleLength == 0 \|\| sampleLength >= filesize)
1302	{
1303	okBoxThreadSafe(0, "System message", "Error loading sample: The sample is not supported or is invalid!");
1304	goto wavLoadError;
1305	}
1306
1307	if (audioFormat != WAV_FORMAT_PCM && audioFormat != WAV_FORMAT_IEEE_FLOAT)
1308	{
1309	okBoxThreadSafe(0, "System message", "Error loading sample: The sample is not supported!");
1310	goto wavLoadError;
1311	}
1312
1313	if (numChannels == 0 \|\| numChannels > 2)
1314	{
1315	okBoxThreadSafe(0, "System message", "Error loading sample: Unsupported number of channels!");
1316	goto wavLoadError;
1317	}
1318
1319	if (audioFormat == WAV_FORMAT_IEEE_FLOAT && bitsPerSample != 32 && bitsPerSample != 64)
1320	{
1321	okBoxThreadSafe(0, "System message", "Error loading sample: Unsupported bitdepth!");
1322	goto wavLoadError;
1323	}
1324
1325	if (bitsPerSample != 8 && bitsPerSample != 16 && bitsPerSample != 24 && bitsPerSample != 32 && bitsPerSample != 64)
1326	{
1327	okBoxThreadSafe(0, "System message", "Error loading sample: Unsupported bitdepth!");
1328	goto wavLoadError;
1329	}
1330
1331	// ---- READ SAMPLE DATA ----
1332	fseek(f, dataPtr, SEEK_SET);
1333
1334	s = &instr[editor.curInstr]->samp[editor.curSmp];
1335	tmpSmp.pan = 128;
1336	tmpSmp.vol = 64;
1337
1338	if (sampleLength > MAX_SAMPLE_LEN)
1339	sampleLength = MAX_SAMPLE_LEN;
1340
1341	if (bitsPerSample == 8) // 8-BIT INTEGER SAMPLE
1342	{
1343	tmpSmp.origPek = (int8_t *)malloc(sampleLength + LOOP_FIX_LEN);
1344	if (tmpSmp.origPek == NULL)
1345	{
1346	okBoxThreadSafe(0, "System message", "Not enough memory!");
1347	goto wavLoadError;
1348	}
1349
1350	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;
1351
1352	if (fread(tmpSmp.pek, sampleLength, 1, f) != 1)
1353	{
1354	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
1355	goto wavLoadError;
1356	}
1357
1358	audioDataU8 = (uint8_t *)tmpSmp.pek;
1359
1360	// stereo conversion
1361	if (numChannels == 2)
1362	{
1363	sampleLength /= 2;
1364	switch (stereoSampleLoadMode)
1365	{
1366	case STEREO_SAMPLE_READ_LEFT:
1367	{
1368	// remove right channel data
1369	for (i = 1; i < sampleLength; i++)
1370	audioDataU8[i] = audioDataU8[(i * 2) + 0];
1371	}
1372	break;
1373
1374	case STEREO_SAMPLE_READ_RIGHT:
1375	{
1376	// remove left channel data
1377	len32 = sampleLength - 1;
1378	for (i = 0; i < len32; i++)
1379	audioDataU8[i] = audioDataU8[(i * 2) + 1];
1380
1381	audioDataU8[i] = 128;
1382	}
1383	break;
1384
1385	default:
1386	case STEREO_SAMPLE_CONVERT:
1387	{
1388	// mix stereo to mono
1389	len32 = sampleLength - 1;
1390	for (i = 0; i < len32; i++)
1391	audioDataU8[i] = (audioDataU8[(i * 2) + 0] + audioDataU8[(i * 2) + 1]) >> 1;
1392
1393	audioDataU8[i] = 128;
1394	}
1395	break;
1396	}
1397	}
1398
1399	// convert from unsigned to signed
1400	for (i = 0; i < sampleLength; i++)
1401	tmpSmp.pek[i] ^= 0x80;
1402
1403	tmpSmp.typ &= ~16; // 8-bit
1404	}
1405	else if (bitsPerSample == 16) // 16-BIT INTEGER SAMPLE
1406	{
1407	sampleLength /= 2;
1408
1409	tmpSmp.origPek = (int8_t )malloc((sampleLength 2) + LOOP_FIX_LEN);
1410	if (tmpSmp.origPek == NULL)
1411	{
1412	okBoxThreadSafe(0, "System message", "Not enough memory!");
1413	goto wavLoadError;
1414	}
1415
1416	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;
1417
1418	if (fread(tmpSmp.pek, sampleLength, 2, f) != 2)
1419	{
1420	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
1421	goto wavLoadError;
1422	}
1423
1424	audioDataS16 = (int16_t *)tmpSmp.pek;
1425
1426	// stereo conversion
1427	if (numChannels == 2)
1428	{
1429	sampleLength /= 2;
1430
1431	switch (stereoSampleLoadMode)
1432	{
1433	case STEREO_SAMPLE_READ_LEFT:
1434	{
1435	// remove right channel data
1436	for (i = 1; i < sampleLength; i++)
1437	audioDataS16[i] = audioDataS16[(i * 2) + 0];
1438	}
1439	break;
1440
1441	case STEREO_SAMPLE_READ_RIGHT:
1442	{
1443	// remove left channel data
1444	len32 = sampleLength - 1;
1445	for (i = 0; i < len32; i++)
1446	audioDataS16[i] = audioDataS16[(i * 2) + 1];
1447
1448	audioDataS16[i] = 0;
1449	}
1450	break;
1451
1452	default:
1453	case STEREO_SAMPLE_CONVERT:
1454	{
1455	// mix stereo to mono
1456	len32 = sampleLength - 1;
1457	for (i = 0; i < len32; i++)
1458	{
1459	smp32 = audioDataS16[(i * 2) + 0] + audioDataS16[(i * 2) + 1];
1460	audioDataS16[i] = (int16_t)(smp32 >> 1);
1461	}
1462
1463	audioDataS16[i] = 0;
1464	}
1465	break;
1466	}
1467	}
1468
1469	sampleLength *= 2;
1470	tmpSmp.typ \|= 16; // 16-bit
1471	}
1472	else if (bitsPerSample == 24) // 24-BIT INTEGER SAMPLE
1473	{
1474	sampleLength /= 3;
1475
1476	tmpSmp.origPek = (int8_t )malloc(((sampleLength 4) * 2) + LOOP_FIX_LEN);
1477	if (tmpSmp.origPek == NULL)
1478	{
1479	okBoxThreadSafe(0, "System message", "Not enough memory!");
1480	goto wavLoadError;
1481	}
1482
1483	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;
1484
1485	if (fread(&tmpSmp.pek[sampleLength], sampleLength, 3, f) != 3)
1486	{
1487	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
1488	goto wavLoadError;
1489	}
1490
1491	audioDataS32 = (int32_t *)tmpSmp.pek;
1492
1493	// convert to 32-bit
1494	audioDataU8 = (uint8_t *)tmpSmp.pek + sampleLength;
1495	for (i = 0; i < sampleLength; i++)
1496	{
1497	audioDataS32[i] = (audioDataU8[2] << 24) \| (audioDataU8[1] << 16) \| (audioDataU8[0] << 8);
1498	audioDataU8 += 3;
1499	}
1500
1501	// stereo conversion
1502	if (numChannels == 2)
1503	{
1504	sampleLength /= 2;
1505	switch (stereoSampleLoadMode)
1506	{
1507	case STEREO_SAMPLE_READ_LEFT:
1508	{
1509	// remove right channel data
1510	for (i = 1; i < sampleLength; i++)
1511	audioDataS32[i] = audioDataS32[(i * 2) + 0];
1512	}
1513	break;
1514
1515	case STEREO_SAMPLE_READ_RIGHT:
1516	{
1517	// remove left channel data
1518	len32 = sampleLength - 1;
1519	for (i = 0; i < len32; i++)
1520	audioDataS32[i] = audioDataS32[(i * 2) + 1];
1521
1522	audioDataS32[i] = 0;
1523	}
1524	break;
1525
1526	default:
1527	case STEREO_SAMPLE_CONVERT:
1528	{
1529	// mix stereo to mono
1530	len32 = sampleLength - 1;
1531	for (i = 0; i < len32; i++)
1532	{
1533	smp64 = audioDataS32[(i * 2) + 0];
1534	smp64 += audioDataS32[(i * 2) + 1];
1535	smp64 >>= 1;
1536
1537	audioDataS32[i] = (int32_t)smp64;
1538	}
1539
1540	audioDataS32[i] = 0;
1541	}
1542	break;
1543	}
1544	}
1545
1546	normalize32bitSigned(audioDataS32, sampleLength);
1547
1548	// downscale to 16-bit (ultra fast method!)
1549
1550	audioDataS16 = (int16_t *)tmpSmp.pek;
1551	audioDataS16_2 = (int16_t *)tmpSmp.pek + 1;
1552
1553	for (i = 0; i < sampleLength; i++)
1554	{
1555	audioDataS16[i] = audioDataS16_2[i];
1556	audioDataS16_2++;
1557	}
1558
1559	sampleLength *= 2;
1560	tmpSmp.typ \|= 16; // 16-bit
1561	}
1562	else if (audioFormat == WAV_FORMAT_PCM && bitsPerSample == 32) // 32-BIT INTEGER SAMPLE
1563	{
1564	sampleLength /= 4;
1565
1566	tmpSmp.origPek = (int8_t )malloc((sampleLength 4) + LOOP_FIX_LEN);
1567	if (tmpSmp.origPek == NULL)
1568	{
1569	okBoxThreadSafe(0, "System message", "Not enough memory!");
1570	goto wavLoadError;
1571	}
1572
1573	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;
1574
1575	if (fread(tmpSmp.pek, sampleLength, 4, f) != 4)
1576	{
1577	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
1578	goto wavLoadError;
1579	}
1580
1581	audioDataS32 = (int32_t *)tmpSmp.pek;
1582
1583	// stereo conversion
1584	if (numChannels == 2)
1585	{
1586	sampleLength /= 2;
1587	switch (stereoSampleLoadMode)
1588	{
1589	case STEREO_SAMPLE_READ_LEFT:
1590	{
1591	// remove right channel data
1592	for (i = 1; i < sampleLength; i++)
1593	audioDataS32[i] = audioDataS32[(i * 2) + 0];
1594	}
1595	break;
1596
1597	case STEREO_SAMPLE_READ_RIGHT:
1598	{
1599	// remove left channel data
1600	len32 = sampleLength - 1;
1601	for (i = 0; i < len32; i++)
1602	audioDataS32[i] = audioDataS32[(i * 2) + 1];
1603
1604	audioDataS32[i] = 0;
1605	}
1606	break;
1607
1608	default:
1609	case STEREO_SAMPLE_CONVERT:
1610	{
1611	// mix stereo to mono
1612	len32 = sampleLength - 1;
1613	for (i = 0; i < len32; i++)
1614	{
1615	smp64 = audioDataS32[(i * 2) + 0];
1616	smp64 += audioDataS32[(i * 2) + 1];
1617	smp64 >>= 1;
1618
1619	audioDataS32[i] = (int32_t)smp64;
1620	}
1621
1622	audioDataS32[i] = 0;
1623	}
1624	break;
1625	}
1626	}
1627
1628	normalize32bitSigned(audioDataS32, sampleLength);
1629
1630	// downscale to 16-bit (ultra fast method!)
1631
1632	audioDataS16 = (int16_t *)tmpSmp.pek;
1633	audioDataS16_2 = (int16_t *)tmpSmp.pek + 1;
1634
1635	for (i = 0; i < sampleLength; i++)
1636	{
1637	audioDataS16[i] = audioDataS16_2[i];
1638	audioDataS16_2++;
1639	}
1640
1641	sampleLength *= 2;
1642	tmpSmp.typ \|= 16; // 16-bit
1643	}
1644	else if (audioFormat == WAV_FORMAT_IEEE_FLOAT && bitsPerSample == 32) // 32-BIT FLOATING POINT SAMPLE
1645	{
1646	sampleLength /= 4;
1647		31
1648	tmpSmp.origPek = (int8_t )malloc((sampleLength 4) + LOOP_FIX_LEN);	32	// file extensions accepted by Disk Op. in sample mode
1649	if (tmpSmp.origPek == NULL)	33	char *supportedSmpExtensions[] =
1650	{	34	{
1651	okBoxThreadSafe(0, "System message", "Not enough memory!");	35	"iff", "raw", "wav", "snd", "smp", "sam", "aif", "pat", "aiff",
1652	goto wavLoadError;
1653	}
1654		36
1655	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;	37	"END_OF_LIST" // do NOT move, remove or edit this line!
		38	};
1656		39
1657	if (fread(tmpSmp.pek, sampleLength, 4, f) != 4)	40	// globals for sample loaders
1658	{	41	bool loadAsInstrFlag, smpFilenameSet;
1659	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");	42	char *smpFilename;
1660	goto wavLoadError;	43	uint8_t sampleSlot;
1661	}	44	sampleTyp tmpSmp;
		45	// --------------------------
1662		46
1663	fAudioDataFloat = (float *)tmpSmp.pek;	47	static volatile bool sampleIsLoading;
		48	static SDL_Thread *thread;
1664		49
1665	// stereo conversion	50	static void freeTmpSample(sampleTyp *s);
1666	if (numChannels == 2)
1667	{
1668	sampleLength /= 2;
1669	switch (stereoSampleLoadMode)
1670	{
1671	case STEREO_SAMPLE_READ_LEFT:
1672	{
1673	// remove right channel data
1674	for (i = 1; i < sampleLength; i++)
1675	fAudioDataFloat[i] = fAudioDataFloat[(i * 2) + 0];
1676	}
1677	break;
1678		51
1679	case STEREO_SAMPLE_READ_RIGHT:	52	// Crude sample detection routine. These aren't always accurate detections!
1680	{	53	static int8_t detectSample(FILE *f)
1681	// remove left channel data	54	{
1682	len32 = sampleLength - 1;	55	uint8_t D[256];
1683	for (i = 0; i < len32; i++)
1684	fAudioDataFloat[i] = fAudioDataFloat[(i * 2) + 1];
1685		56
1686	fAudioDataFloat[i] = 0.0f;	57	uint32_t oldPos = ftell(f);
1687	}	58	rewind(f);
1688	break;	59	memset(D, 0, sizeof (D));
		60	fread(D, 1, sizeof (D), f);
		61	fseek(f, oldPos, SEEK_SET);
1689		62
1690	default:	63	if (!memcmp("FORM", &D[0], 4) && (!memcmp("8SVX", &D[8], 4) \|\| !memcmp("16SV", &D[8], 4)))
1691	case STEREO_SAMPLE_CONVERT:	64	return FORMAT_IFF;
1692	{
1693	// mix stereo to mono
1694	len32 = sampleLength - 1;
1695	for (i = 0; i < len32; i++)
1696	fAudioDataFloat[i] = (fAudioDataFloat[(i * 2) + 0] + fAudioDataFloat[(i * 2) + 1]) * 0.5f;
1697		65
1698	fAudioDataFloat[i] = 0.0f;	66	if (!memcmp("RIFF", &D[0], 4) && !memcmp("WAVE", &D[8], 4))
1699	}	67	return FORMAT_WAV;
1700	break;
1701	}
1702	}
1703		68
1704	normalize16bitFloatSigned(fAudioDataFloat, sampleLength);	69	if (!memcmp("FORM", &D[0], 4) && (!memcmp("AIFF", &D[8], 4) \|\| !memcmp("AIFC", &D[8], 4)))
		70	return FORMAT_AIFF;
1705		71
1706	ptr16 = (int16_t *)tmpSmp.pek;	72	return FORMAT_UNKNOWN;
1707	for (i = 0; i < sampleLength; i++)	73	}
1708	ptr16[i] = (int16_t)fAudioDataFloat[i]; // should use SIMD if available
1709		74
1710	sampleLength *= 2;	75	static int32_t SDLCALL loadSampleThread(void *ptr)
1711	tmpSmp.typ \|= 16; // 16-bit	76	{
1712	}	77	if (editor.tmpFilenameU == NULL)
1713	else if (audioFormat == WAV_FORMAT_IEEE_FLOAT && bitsPerSample == 64) // 64-BIT FLOATING POINT SAMPLE
1714	{	78	{
1715	sampleLength /= 8;	79	loaderMsgBox("General I/O error during loading!");
1716		80	return false;
1717	tmpSmp.origPek = (int8_t )malloc((sampleLength 8) + LOOP_FIX_LEN);
1718	if (tmpSmp.origPek == NULL)
1719	{
1720	okBoxThreadSafe(0, "System message", "Not enough memory!");
1721	goto wavLoadError;
1722	}
1723
1724	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;
1725
1726	if (fread(tmpSmp.pek, sampleLength, 8, f) != 8)
1727	{
1728	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
1729	goto wavLoadError;
1730	}
1731
1732	dAudioDataDouble = (double *)tmpSmp.pek;
1733
1734	// stereo conversion
1735	if (numChannels == 2)
1736	{
1737	sampleLength /= 2;
1738	switch (stereoSampleLoadMode)
1739	{
1740	case STEREO_SAMPLE_READ_LEFT:
1741	{
1742	// remove right channel data
1743	for (i = 1; i < sampleLength; i++)
1744	dAudioDataDouble[i] = dAudioDataDouble[(i * 2) + 0];
1745	}
1746	break;
1747
1748	case STEREO_SAMPLE_READ_RIGHT:
1749	{
1750	// remove left channel data
1751	len32 = sampleLength - 1;
1752	for (i = 0; i < len32; i++)
1753	dAudioDataDouble[i] = dAudioDataDouble[(i * 2) + 1];
1754
1755	dAudioDataDouble[i] = 0.0;
1756	}
1757	break;
1758
1759	default:
1760	case STEREO_SAMPLE_CONVERT:
1761	{
1762	// mix stereo to mono
1763	len32 = sampleLength - 1;
1764	for (i = 0; i < len32; i++)
1765	dAudioDataDouble[i] = (dAudioDataDouble[(i * 2) + 0] + dAudioDataDouble[(i * 2) + 1]) * 0.5;
1766
1767	dAudioDataDouble[i] = 0.0;
1768	}
1769	break;
1770	}
1771	}
1772
1773	normalize64bitDoubleSigned(dAudioDataDouble, sampleLength);
1774
1775	ptr16 = (int16_t *)tmpSmp.pek;
1776	for (i = 0; i < sampleLength; i++)
1777	ptr16[i] = (int16_t)dAudioDataDouble[i]; // should use SIMD if available
1778
1779	sampleLength *= 2;
1780	tmpSmp.typ \|= 16; // 16-bit
1781	}	81	}
1782		82
1783	// adjust memory needed	83	FILE *f = UNICHAR_FOPEN(editor.tmpFilenameU, "rb");
1784	newPtr = (int8_t *)realloc(tmpSmp.origPek, sampleLength + LOOP_FIX_LEN);	84	if (f == NULL)
1785	if (newPtr != NULL)
1786	{	85	{
1787	tmpSmp.origPek = newPtr;	86	loaderMsgBox("General I/O error during loading! Is the file in use?");
1788	tmpSmp.pek = tmpSmp.origPek + SMP_DAT_OFFSET;	87	return false;
1789	}	88	}
1790		89
1791	tuneSample(&tmpSmp, sampleRate, audio.linearPeriodsFlag);	90	int8_t format = detectSample(f);
1792		91	fseek(f, 0, SEEK_END);
1793	tmpSmp.vol = 64;	92	uint32_t filesize = ftell(f);
1794	tmpSmp.pan = 128;
1795	tmpSmp.len = sampleLength;
1796		93
1797	// ---- READ "smpl" chunk ----	94	if (filesize == 0)
1798	if (smplPtr != 0 && smplLen > 52)
1799	{	95	{
1800	fseek(f, smplPtr + 28, SEEK_SET); // seek to first wanted byte	96	fclose(f);
1801		97	loaderMsgBox("Error loading sample: The file is empty!");
1802	fread(&numLoops, 4, 1, f);	98	return false;
1803	if (numLoops == 1)
1804	{
1805	fseek(f, 4 + 4, SEEK_CUR); // skip "samplerData" and "identifier"
1806
1807	fread(&loopType, 4, 1, f);
1808	fread(&loopStart, 4, 1, f);
1809	fread(&loopEnd, 4, 1, f);
1810
1811	loopEnd++;
1812
1813	if (tmpSmp.typ & 16)
1814	{
1815	loopStart *= 2;
1816	loopEnd *= 2;
1817	}
1818
1819	if (loopEnd <= sampleLength)
1820	{
1821	tmpSmp.repS = loopStart;
1822	tmpSmp.repL = loopEnd - loopStart;
1823	tmpSmp.typ \|= ((loopType == 0) ? 1 : 2);
1824	}
1825	}
1826	}	99	}
1827	// ---------------------------
1828
1829	// ---- READ "xtra" chunk ----
1830	if (xtraPtr != 0 && xtraLen >= 8)
1831	{
1832	fseek(f, xtraPtr, SEEK_SET);
1833
1834	fread(&xtraFlags, 4, 1, f); // flags
1835		100
1836	// panning (0..256)	101	bool sampleLoaded = false;
1837	if (xtraFlags & 0x20) // set panning flag
1838	{
1839	fread(&tempPan, 2, 1, f);
1840	if (tempPan > 255)
1841	tempPan = 255;
1842
1843	tmpSmp.pan = (uint8_t)tempPan;
1844	}
1845	else
1846	{
1847	// don't read panning, skip it
1848	fseek(f, 2, SEEK_CUR);
1849	}
1850
1851	// volume (0..256)
1852	fread(&tempVol, 2, 1, f);
1853	if (tempVol > 256)
1854	tempVol = 256;
1855
1856	tmpSmp.vol = (uint8_t)(tempVol / 4); // 0..256 -> 0..64
1857	}
1858	// ---------------------------
1859		102
1860	// ---- READ "INAM" chunk ----	103	rewind(f);
1861	if (inamPtr != 0 && inamLen > 0)	104	switch (format)
1862	{	105	{
1863	fseek(f, inamPtr, SEEK_SET);	106	case FORMAT_IFF: sampleLoaded = loadIFF(f, filesize); break;
		107	case FORMAT_WAV: sampleLoaded = loadWAV(f, filesize); break;
		108	case FORMAT_AIFF: sampleLoaded = loadAIFF(f, filesize); break;
		109	default: sampleLoaded = loadRAW(f, filesize); break;
		110	}
		111	fclose(f);
1864		112
1865	memset(tmpSmp.name, 0, sizeof (tmpSmp.name));	113	if (!sampleLoaded)
1866	for (i = 0; i < 22; i++)	114	goto loadError;
1867	{
1868	if (i < inamLen)
1869	{
1870	chr = (char)fgetc(f);
1871	if (chr == '\0')
1872	break;
1873		115
1874	tmpSmp.name[i] = chr;	116	// sample loaded successfully!
1875	}	117
1876	}	118	if (!smpFilenameSet) // if we didn't set a custom sample name in the loader, set it to its filename
1877	}
1878	else
1879	{	119	{
1880	// set sample name from filename if we didn't load name from .wav	120	char *tmpFilename = unicharToCp437(editor.tmpFilenameU, true);
1881	tmpFilename = unicharToCp437(filename, true);
1882	if (tmpFilename != NULL)	121	if (tmpFilename != NULL)
1883	{	122	{
1884	j = (int32_t)strlen(tmpFilename);	123	int32_t i = (int32_t)strlen(tmpFilename);
1885	while (j--)	124	while (i--)
1886	{	125	{
1887	if (tmpFilename[j] == DIR_DELIMITER)	126	if (tmpFilename[i] == DIR_DELIMITER)
1888	break;	127	break;
1889	}	128	}
1890		129
1891	tmpPtr = tmpFilename;	130	char *tmpPtr = tmpFilename;
1892	if (j > 0)	131	if (i > 0)
1893	tmpPtr += j + 1;	132	tmpPtr += i+1;
1894		133
1895	sanitizeFilename(tmpPtr);	134	sanitizeFilename(tmpPtr);
1896		135
1897	filenameLen = (uint32_t)strlen(tmpPtr);	136	int32_t filenameLen = (int32_t)strlen(tmpPtr);
1898	for (i = 0; i < 22; i++)	137	for (i = 0; i < 22; i++)
1899	{	138	{
1900	if (i < filenameLen)	139	if (i < filenameLen)
@@ -1907,7 +146,7 @@ static int32_t SDLCALL loadWAVSample(void *ptr) · 6 unmodified lines
1907	}	146	}
1908	}	147	}
1909		148
1910	fclose(f);	149	fixString(tmpSmp.name, 21); // remove leading spaces from sample filename
1911		150
1912	lockMixerCallback();	151	lockMixerCallback();
1913	if (loadAsInstrFlag) // if loaded in instrument mode	152	if (loadAsInstrFlag) // if loaded in instrument mode
@@ -1919,172 +158,82 @@ static int32_t SDLCALL loadWAVSample(void *ptr) · 5 unmodified lines
1919	if (instr[editor.curInstr] == NULL)	158	if (instr[editor.curInstr] == NULL)
1920	allocateInstr(editor.curInstr);	159	allocateInstr(editor.curInstr);
1921		160
1922	if (instr[editor.curInstr] != NULL)	161	if (instr[editor.curInstr] == NULL)
1923	{
1924	s = &instr[editor.curInstr]->samp[sampleSlot];
1925
1926	freeSample(editor.curInstr, sampleSlot);
1927	memcpy(s, &tmpSmp, sizeof (sampleTyp));
1928	fixSample(s);
1929	}
1930	else
1931	{	162	{
1932	okBoxThreadSafe(0, "System message", "Not enough memory!");	163	loaderMsgBox("Not enough memory!");
1933	goto wavLoadError;	164	goto loadError;
1934	}	165	}
		166
		167	sampleTyp *s = &instr[editor.curInstr]->samp[sampleSlot];
		168
		169	freeSample(editor.curInstr, sampleSlot);
		170	memcpy(s, &tmpSmp, sizeof (sampleTyp));
		171	fixSample(s); // prepares sample for branchless resampling interpolation
		172	fixInstrAndSampleNames(editor.curInstr);
		173
1935	unlockMixerCallback();	174	unlockMixerCallback();
1936		175
1937	fixSampleName(editor.curInstr);
1938	setSongModifiedFlag();	176	setSongModifiedFlag();
1939	stereoSampleLoadMode = -1;
1940		177
1941	// also sets mouse busy to false when done	178	// when caught in main/video thread, it disables busy mouse and sets sampleIsLoading to true
1942	editor.updateCurSmp = true;	179	editor.updateCurSmp = true;
1943		180
1944	return true;	181	return true;
1945		182
1946	wavLoadError:	183	loadError:
1947	if (f != NULL) fclose(f);	184	setMouseBusy(false);
1948	if (tmpSmp.origPek != NULL) free(tmpSmp.origPek);	185	freeTmpSample(&tmpSmp);
1949
1950	stereoSampleLoadMode = -1;
1951	sampleIsLoading = false;	186	sampleIsLoading = false;
1952
1953	return false;	187	return false;
1954		188
1955	(void)ptr;	189	(void)ptr;
1956	}	190	}
1957		191
1958	bool loadSample(UNICHAR *filenameU, uint8_t smpNr, bool instrFlag)	192	static void freeTmpSample(sampleTyp *s)
1959	{	193	{
1960	char tmpBuffer[16+1];	194	if (s->origPek != NULL)
1961
1962	if (sampleIsLoading)
1963	return false;
1964
1965	stereoSampleLoadMode = 0;
1966
1967	sampleSlot = smpNr;
1968	loadAsInstrFlag = instrFlag;
1969
1970	if (editor.curInstr == 0)
1971	{
1972	okBox(0, "System message", "The zero-instrument cannot hold intrument data.");
1973	return false;
1974	}
1975
1976	FILE *f = UNICHAR_FOPEN(filenameU, "rb");
1977	if (f == NULL)
1978	{	195	{
1979	okBox(0, "System message", "General I/O error during loading! Is the file in use?");	196	free(s->origPek);
1980	return false;	197	s->origPek = NULL;
1981	}	198	}
1982		199
1983	memset(tmpBuffer, 0, sizeof (tmpBuffer));	200	s->pek = NULL;
1984	if (fread(tmpBuffer, sizeof (tmpBuffer) - 1, 1, f) == 1)	201	}
1985	{
1986	tmpBuffer[sizeof (tmpBuffer) - 1] = '\0';
1987
1988	// detect what sample format this is...
1989
1990	// WAV
1991	if (!strncmp("RIFF", tmpBuffer, 4) && !strncmp("WAVE", tmpBuffer + 8, 4))
1992	{
1993	// let the user pick what to do with stereo samples...
1994	if (wavIsStereo(f))
1995	stereoSampleLoadMode = okBox(5, "System request", "This is a stereo sample...");
1996
1997	sampleIsLoading = true;
1998
1999	fclose(f);
2000	UNICHAR_STRCPY(editor.tmpFilenameU, filenameU);
2001
2002	mouseAnimOn();
2003	thread = SDL_CreateThread(loadWAVSample, NULL, NULL);
2004	if (thread == NULL)
2005	{
2006	okBox(0, "System message", "Couldn't create thread!");
2007	sampleIsLoading = false;
2008	return false;
2009	}
2010
2011	SDL_DetachThread(thread);
2012	return true;
2013	}
2014
2015	// AIFF or IFF
2016	if (!strncmp("FORM", tmpBuffer, 4))
2017	{
2018	if (!strncmp("AIFC", tmpBuffer + 8, 4))
2019	{
2020	// AIFC (not supported)
2021
2022	fclose(f);
2023	okBox(0, "System message", "Error loading sample: This AIFF type (AIFC) is not supported!");
2024	return true;
2025	}
2026	else if (!strncmp("AIFF", tmpBuffer + 8, 4))
2027	{
2028	// AIFF
2029
2030	// let the user pick what to do with stereo samples...
2031	if (aiffIsStereo(f))
2032	stereoSampleLoadMode = okBox(5, "System request", "This is a stereo sample...");
2033
2034	sampleIsLoading = true;
2035
2036	fclose(f);
2037	UNICHAR_STRCPY(editor.tmpFilenameU, filenameU);
2038
2039	mouseAnimOn();
2040	thread = SDL_CreateThread(loadAIFFSample, NULL, NULL);
2041	if (thread == NULL)
2042	{
2043	okBox(0, "System message", "Couldn't create thread!");
2044	sampleIsLoading = false;
2045	return false;
2046	}
2047
2048	SDL_DetachThread(thread);
2049	return true;
2050	}
2051	else if (!strncmp("8SVX", tmpBuffer + 8, 4) \|\| !strncmp("16SV", tmpBuffer + 8, 4))
2052	{
2053	// IFF
2054		202
2055	sampleIsLoading = true;	203	void removeSampleIsLoadingFlag(void)
		204	{
		205	sampleIsLoading = false;
		206	}
2056		207
2057	fclose(f);	208	bool loadSample(UNICHAR *filenameU, uint8_t smpNr, bool instrFlag)
2058	UNICHAR_STRCPY(editor.tmpFilenameU, filenameU);	209	{
		210	if (sampleIsLoading \|\| filenameU == NULL)
		211	return false;
2059		212
2060	mouseAnimOn();	213	// setup message box functions
2061	thread = SDL_CreateThread(loadIFFSample, NULL, NULL);	214	loaderMsgBox = myLoaderMsgBoxThreadSafe;
2062	if (thread == NULL)	215	loaderSysReq = okBoxThreadSafe;
2063	{
2064	okBox(0, "System message", "Couldn't create thread!");
2065	sampleIsLoading = false;
2066	return false;
2067	}
2068		216
2069	SDL_DetachThread(thread);	217	if (editor.curInstr == 0)
2070	return true;	218	{
2071	}	219	loaderMsgBox("The zero-instrument cannot hold intrument data.");
2072	}	220	return false;
2073	}	221	}
2074		222
2075	// load as RAW sample	223	sampleSlot = smpNr;
2076		224	loadAsInstrFlag = instrFlag;
2077	sampleIsLoading = true;	225	sampleIsLoading = true;
		226	smpFilenameSet = false;
2078		227
2079	fclose(f);	228	memset(&tmpSmp, 0, sizeof (tmpSmp));
2080	UNICHAR_STRCPY(editor.tmpFilenameU, filenameU);	229	UNICHAR_STRCPY(editor.tmpFilenameU, filenameU);
2081		230
2082	mouseAnimOn();	231	mouseAnimOn();
2083	thread = SDL_CreateThread(loadRawSample, NULL, NULL);	232	thread = SDL_CreateThread(loadSampleThread, NULL, NULL);
2084	if (thread == NULL)	233	if (thread == NULL)
2085	{	234	{
2086	okBox(0, "System message", "Couldn't create thread!");
2087	sampleIsLoading = false;	235	sampleIsLoading = false;
		236	loaderMsgBox("Couldn't create thread!");
2088	return false;	237	return false;
2089	}	238	}
2090		239
@@ -2092,7 +241,7 @@ bool loadSample(UNICHAR *filenameU, uint8_t smpNr, bool instrFlag) · 1 unmodified line
2092	return true;	241	return true;
2093	}	242	}
2094		243
2095	static void normalize32bitSigned(int32_t *sampleData, uint32_t sampleLength)	244	void normalizeSigned32Bit(int32_t *sampleData, uint32_t sampleLength)
2096	{	245	{
2097	uint32_t i;	246	uint32_t i;
2098		247
@@ -2112,7 +261,7 @@ static void normalize32bitSigned(int32_t *sampleData, uint32_t sampleLength) · 13 unmodified lines
2112	sampleData[i] = (int32_t)(sampleData[i] * dGain);	261	sampleData[i] = (int32_t)(sampleData[i] * dGain);
2113	}	262	}
2114		263
2115	static void normalize16bitFloatSigned(float *fSampleData, uint32_t sampleLength)	264	void normalize32BitFloatToSigned16Bit(float *fSampleData, uint32_t sampleLength)
2116	{	265	{
2117	uint32_t i;	266	uint32_t i;
2118		267
@@ -2132,7 +281,7 @@ static void normalize16bitFloatSigned(float *fSampleData, uint32_t sampleLength) · 13 unmodified lines
2132	fSampleData[i] *= fGain;	281	fSampleData[i] *= fGain;
2133	}	282	}
2134		283
2135	static void normalize64bitDoubleSigned(double *dSampleData, uint32_t sampleLength)	284	void normalize64BitFloatToSigned16Bit(double *dSampleData, uint32_t sampleLength)
2136	{	285	{
2137	uint32_t i;	286	uint32_t i;
2138		287
@@ -2151,98 +300,3 @@ static void normalize64bitDoubleSigned(double *dSampleData, uint32_t sampleLengt · 12 unmodified lines
2151	for (i = 0; i < sampleLength; i++)	300	for (i = 0; i < sampleLength; i++)
2152	dSampleData[i] *= dGain;	301	dSampleData[i] *= dGain;
2153	}	302	}
2154
2155	bool fileIsInstrument(char *fullPath)
2156	{
2157	int32_t i, len;
2158
2159	// this assumes that fullPath is not empty
2160
2161	len = (int32_t)strlen(fullPath);
2162
2163	// get filename from path
2164	i = len;
2165	while (i--)
2166	{
2167	if (fullPath[i] == DIR_DELIMITER)
2168	break;
2169	}
2170
2171	char *filename = fullPath;
2172	if (i > 0)
2173	filename += i + 1;
2174	// --------------------------
2175
2176	len = (int32_t)strlen(filename);
2177	if (len < 4)
2178	return true; // can't be an instrument
2179
2180	if (!_strnicmp("xi.", filename, 3) \|\| (len >= 4 && !_strnicmp("pat.", filename, 4)))
2181	return true;
2182
2183	int32_t extOffset = getExtOffset(filename, len);
2184	if (extOffset != -1)
2185	{
2186	if ((extOffset <= len-4) && !_strnicmp(".pat", &filename[extOffset], 4)) return true;
2187	if ((extOffset <= len-3) && !_strnicmp(".xi", &filename[extOffset], 3)) return true;
2188	}
2189
2190	return false;
2191	}
2192
2193	bool fileIsSample(char *fullPath)
2194	{
2195	int32_t i, len;
2196
2197	// this assumes that fullPath is not empty
2198
2199	len = (int32_t)strlen(fullPath);
2200
2201	// get filename from path
2202	i = len;
2203	while (i--)
2204	{
2205	if (fullPath[i] == DIR_DELIMITER)
2206	break;
2207	}
2208
2209	char *filename = fullPath;
2210	if (i > 0)
2211	filename += i + 1;
2212	// --------------------------
2213
2214	len = (int32_t)strlen(filename);
2215	if (len < 4)
2216	return true; // can't be a module
2217
2218	if (!_strnicmp("xm.", filename, 3) \|\| !_strnicmp("ft.", filename, 3) \|\|
2219	!_strnicmp("mod.", filename, 4) \|\| !_strnicmp("nst.", filename, 4) \|\|
2220	!_strnicmp("s3m.", filename, 4) \|\| !_strnicmp("stm.", filename, 4) \|\|
2221	!_strnicmp("fst.", filename, 4) \|\| !_strnicmp("it.", filename, 3))
2222	{
2223	return false; // definitely a module
2224	}
2225
2226	int32_t extOffset = getExtOffset(filename, len);
2227	if (extOffset != -1)
2228	{
2229	if (extOffset <= len-4)
2230	{
2231	filename = &filename[extOffset];
2232	if (!_strnicmp(".mod", filename, 4) \|\| !_strnicmp(".nst", filename, 4) \|\|
2233	!_strnicmp(".s3m", filename, 4) \|\| !_strnicmp(".stm", filename, 4) \|\|
2234	!_strnicmp(".fst", filename, 4))
2235	{
2236	return false; // definitely a module
2237	}
2238	}
2239	else if (extOffset <= len-3)
2240	{
2241	filename = &filename[extOffset];
2242	if (!_strnicmp(".xm", filename, 3) \|\| !_strnicmp(".ft", filename, 3) \|\| !_strnicmp(".it", filename, 3))
2243	return false; // definitely a module
2244	}
2245	}
2246
2247	return true; // let's assume it's a sample
2248	}

src/ft2_sample_loader.h+22−2

@@ -2,9 +2,29 @@ · 1 unmodified line
2		2
3	#include <stdint.h>	3	#include <stdint.h>
4	#include <stdbool.h>	4	#include <stdbool.h>
		5	#include "ft2_header.h"
5	#include "ft2_unicode.h"	6	#include "ft2_unicode.h"
6		7
		8	enum
		9	{
		10	STEREO_SAMPLE_READ_LEFT = 1,
		11	STEREO_SAMPLE_READ_RIGHT = 2,
		12	STEREO_SAMPLE_CONVERT = 3,
		13	};
		14
		15	void normalizeSigned32Bit(int32_t *sampleData, uint32_t sampleLength);
		16	void normalize32BitFloatToSigned16Bit(float *fSampleData, uint32_t sampleLength);
		17	void normalize64BitFloatToSigned16Bit(double *dSampleData, uint32_t sampleLength);
		18
7	bool loadSample(UNICHAR *filenameU, uint8_t sampleSlot, bool loadAsInstrFlag);	19	bool loadSample(UNICHAR *filenameU, uint8_t sampleSlot, bool loadAsInstrFlag);
8	bool fileIsInstrument(char *fullPath);
9	bool fileIsSample(char *fullPath);
10	void removeSampleIsLoadingFlag(void);	20	void removeSampleIsLoadingFlag(void);
		21
		22	// globals for sample loaders
		23	extern bool loadAsInstrFlag, smpFilenameSet;
		24	extern char *smpFilename;
		25	extern uint8_t sampleSlot;
		26	extern sampleTyp tmpSmp;
		27	// --------------------------
		28
		29	// file extensions accepted by Disk Op. in sample mode
		30	extern char *supportedSmpExtensions[];

src/ft2_scopes.c+17−18

@@ -23,8 +23,6 @@ · 22 unmodified lines
23	#include "ft2_tables.h"	23	#include "ft2_tables.h"
24	#include "ft2_structs.h"	24	#include "ft2_structs.h"
25		25
26	#define SCOPE_HEIGHT 36
27
28	static volatile bool scopesUpdatingFlag, scopesDisplayingFlag;	26	static volatile bool scopesUpdatingFlag, scopesDisplayingFlag;
29	static uint32_t scopeTimeLen, scopeTimeLenFrac;	27	static uint32_t scopeTimeLen, scopeTimeLenFrac;
30	static uint64_t timeNext64, timeNext64Frac;	28	static uint64_t timeNext64, timeNext64Frac;
@@ -38,9 +36,9 @@ void resetCachedScopeVars(void) · 7 unmodified lines
38	volatile scope_t *sc = scope;	36	volatile scope_t *sc = scope;
39	for (int32_t i = 0; i < MAX_VOICES; i++, sc++)	37	for (int32_t i = 0; i < MAX_VOICES; i++, sc++)
40	{	38	{
41	sc->oldPeriod = -1;	39	sc->dOldHz = -1.0;
42	sc->oldDrawDelta = 0;
43	sc->oldDelta = 0;	40	sc->oldDelta = 0;
		41	sc->oldDrawDelta = 0;
44	}	42	}
45	}	43	}
46		44
@@ -353,10 +351,13 @@ static void scopeTrigger(int32_t ch, const sampleTyp *s, int32_t playOffset) · 306 unmodified lines
353	return;	351	return;
354	}	352	}
355		353
356	// these has to be read	354	// these has to be copied so that they are not lost
357	tempState.wasCleared = sc->wasCleared;	355	tempState.wasCleared = sc->wasCleared;
358	tempState.delta = sc->delta;	356	tempState.delta = sc->delta;
		357	tempState.oldDelta = sc->oldDelta;
359	tempState.drawDelta = sc->drawDelta;	358	tempState.drawDelta = sc->drawDelta;
		359	tempState.oldDrawDelta = sc->oldDrawDelta;
		360	tempState.dOldHz = sc->dOldHz;
360	tempState.vol = sc->vol;	361	tempState.vol = sc->vol;
361		362
362	tempState.active = true;	363	tempState.active = true;
@@ -367,6 +368,7 @@ static void scopeTrigger(int32_t ch, const sampleTyp *s, int32_t playOffset) · 4 unmodified lines
367	** the trigger never happens. So far I have never seen it happen,	368	** the trigger never happens. So far I have never seen it happen,
368	** so it's probably very rare. Yes, this is not good coding...	369	** so it's probably very rare. Yes, this is not good coding...
369	*/	370	*/
		371
370	*sc = tempState;	372	*sc = tempState;
371	}	373	}
372		374
@@ -386,8 +388,8 @@ static void updateScopes(void) · 13 unmodified lines
386	// scope position update	388	// scope position update
387		389
388	s.posFrac += s.delta;	390	s.posFrac += s.delta;
389	const int32_t wholeSamples = (int32_t)(s.posFrac >> SCOPE_FRAC_BITS);	391	const int32_t wholeSamples = s.posFrac >> 32;
390	s.posFrac &= SCOPE_FRAC_MASK;	392	s.posFrac &= 0xFFFFFFFF;
391		393
392	if (s.direction == 1)	394	if (s.direction == 1)
393	s.pos += wholeSamples; // forwards	395	s.pos += wholeSamples; // forwards
@@ -522,23 +524,20 @@ void handleScopesFromChQueue(chSyncData_t chSyncData, uint8_t scopeUpdateStatu · 128 unmodified lines
522	const uint8_t status = scopeUpdateStatus[i];	524	const uint8_t status = scopeUpdateStatus[i];
523		525
524	if (status & IS_Vol)	526	if (status & IS_Vol)
525	sc->vol = (int32_t)((ch->dFinalVol * SCOPE_HEIGHT) + 0.5); // rounded	527	sc->vol = ((ch->vol * SCOPE_HEIGHT) + 128) >> 8; // rounded
526		528
527	if (status & IS_Period)	529	if (status & IS_Period)
528	{	530	{
529	// use cached values if possible	531	// use cached values when possible
530		532	if (ch->dHz != sc->dOldHz)
531	const uint16_t period = ch->finalPeriod;
532	if (period != sc->oldPeriod)
533	{	533	{
534	sc->oldPeriod = period;	534	sc->dOldHz = ch->dHz;
535	const double dHz = dPeriod2Hz(period);
536		535
537	const double dScopeRateFactor = SCOPE_FRAC_SCALE / (double)SCOPE_HZ;	536	const double dHz2ScopeDeltaMul = SCOPE_FRAC_SCALE / (double)SCOPE_HZ;
538	sc->oldDelta = (int64_t)((dHz * dScopeRateFactor) + 0.5); // Hz -> rounded fixed-point delta	537	sc->oldDelta = (int64_t)((ch->dHz * dHz2ScopeDeltaMul) + 0.5); // Hz -> 32.32fp delta (rounded)
539		538
540	const double dRelativeHz = dHz * (1.0 / (8363.0 / 2.0));	539	const double dRelativeHz = ch->dHz * (1.0 / (8363.0 / 2.0));
541	sc->oldDrawDelta = (int32_t)((dRelativeHz * SCOPE_DRAW_FRAC_SCALE) + 0.5); // Hz -> rounded fixed-point draw delta	540	sc->oldDrawDelta = (int32_t)((dRelativeHz * SCOPE_DRAW_FRAC_SCALE) + 0.5); // Hz -> 13.19fp draw delta (rounded)
542	}	541	}
543		542
544	sc->delta = sc->oldDelta;	543	sc->delta = sc->oldDelta;

src/ft2_scopes.h+6−2

 #include "ft2_header.h"
 #include "ft2_audio.h"
+#define SCOPE_HEIGHT 36
 #define SCOPE_FRAC_BITS 32
 #define SCOPE_FRAC_SCALE (1ULL << SCOPE_FRAC_BITS)
 #define SCOPE_FRAC_MASK (SCOPE_FRAC_SCALE-1)
 	const int16_t *base16;
 	bool wasCleared, sampleIs16Bit;
 	uint8_t loopType;
-	int32_t vol, loopStart, loopLength, end, pos, direction, oldPeriod;
+	int32_t vol, loopStart, loopLength, end, pos, direction;
 	uint32_t drawDelta, oldDrawDelta;
-	uint64_t delta, posFrac, oldDelta;
+	uint64_t delta, oldDelta, posFrac;
+	double dOldHz;
 } scope_t;
 typedef struct lastChInstr_t

src/ft2_sysreqs.c+32−1

@@ -1,3 +1,4 @@
		1	#include <stdio.h> // vsnprintf()
1	#include <stdint.h>	2	#include <stdint.h>
2	#include <stdbool.h>	3	#include <stdbool.h>
3	#include "ft2_config.h"	4	#include "ft2_config.h"
@@ -16,7 +17,11 @@ · 12 unmodified lines
16		17
17	#define NUM_SYSREQ_TYPES 10	18	#define NUM_SYSREQ_TYPES 10
18		19
19	okBoxData_t okBoxData; // globalized	20	// globalized
		21	okBoxData_t okBoxData;
		22	void (loaderMsgBox)(const char , ...);
		23	int16_t (loaderSysReq)(int16_t, const char , const char *);
		24	// ----------------
20		25
21	static char *buttonText[NUM_SYSREQ_TYPES][5] =	26	static char *buttonText[NUM_SYSREQ_TYPES][5] =
22	{	27	{
@@ -70,6 +75,32 @@ static quitType_t quitMessage[QUIT_MESSAGES] = · 47 unmodified lines
70	{ "Hope you're doing the compulsory \"Exit ceremony\" before pressing >OK<.", 1 },	75	{ "Hope you're doing the compulsory \"Exit ceremony\" before pressing >OK<.", 1 },
71	};	76	};
72		77
		78	void myLoaderMsgBoxThreadSafe(const char *fmt, ...)
		79	{
		80	char strBuf[512];
		81	va_list args;
		82
		83	// format the text string
		84	va_start(args, fmt);
		85	vsnprintf(strBuf, sizeof (strBuf), fmt, args);
		86	va_end(args);
		87
		88	okBoxThreadSafe(0, "System message", fmt);
		89	}
		90
		91	void myLoaderMsgBox(const char *fmt, ...)
		92	{
		93	char strBuf[512];
		94	va_list args;
		95
		96	// format the text string
		97	va_start(args, fmt);
		98	vsnprintf(strBuf, sizeof (strBuf), fmt, args);
		99	va_end(args);
		100
		101	okBox(0, "System message", fmt);
		102	}
		103
73	static void drawWindow(uint16_t w)	104	static void drawWindow(uint16_t w)
74	{	105	{
75	const uint16_t h = SYSTEM_REQUEST_H;	106	const uint16_t h = SYSTEM_REQUEST_H;

src/ft2_sysreqs.h+18−11

@@ -3,11 +3,11 @@ · 2 unmodified lines
3	#include <stdint.h>	3	#include <stdint.h>
4	#include <stdbool.h>	4	#include <stdbool.h>
5		5
6	int16_t okBoxThreadSafe(int16_t typ, const char headline, const char text);	6	enum
7	int16_t okBox(int16_t typ, const char headline, const char text);	7	{
8	int16_t quitBox(bool skipQuitMsg);	8	ASK_TYPE_QUIT = 0,
9	int16_t inputBox(int16_t typ, const char headline, char edText, uint16_t maxStrLen);	9	ASK_TYPE_LOAD_SONG = 1,
10	bool askUnsavedChanges(uint8_t type);	10	};
11		11
12	// for thread-safe version of okBox()	12	// for thread-safe version of okBox()
13	typedef struct okBoxData_t	13	typedef struct okBoxData_t
@@ -17,10 +17,17 @@ typedef struct okBoxData_t · 3 unmodified lines
17	const char headline, text;	17	const char headline, text;
18	} okBoxData_t;	18	} okBoxData_t;
19		19
20	extern okBoxData_t okBoxData; // ft2_sysreqs.c	20	int16_t okBoxThreadSafe(int16_t typ, const char headline, const char text);
		21	int16_t okBox(int16_t typ, const char headline, const char text);
		22	int16_t quitBox(bool skipQuitMsg);
		23	int16_t inputBox(int16_t typ, const char headline, char edText, uint16_t maxStrLen);
		24	bool askUnsavedChanges(uint8_t type);
21		25
22	enum	26	void myLoaderMsgBoxThreadSafe(const char *fmt, ...);
23	{	27	void myLoaderMsgBox(const char *fmt, ...);
24	ASK_TYPE_QUIT = 0,	28
25	ASK_TYPE_LOAD_SONG = 1,	29	// ft2_sysreqs.c
26	};	30	extern okBoxData_t okBoxData;
		31	extern void (loaderMsgBox)(const char , ...);
		32	extern int16_t (loaderSysReq)(int16_t, const char , const char *);
		33	// ---------------

src/ft2_tables.c+8−1

 /*                             REPLAYER TABLES                             */
 /* ----------------------------------------------------------------------- */
+const uint16_t ptPeriods[3 * 12] =
+{
+	856,808,762,720,678,640,604,570,538,508,480,453,
+	428,404,381,360,339,320,302,285,269,254,240,226,
+	214,202,190,180,170,160,151,143,135,127,120,113
+};
 const uint8_t arpTab[256] =
 {
 	0,1,2,0,1,2,0,1,2,0,1,2,0,1,2,0,
 	255,253,250,244,235,224,212,197,180,161,141,120, 97, 74, 49, 24
 };
-const uint16_t amigaPeriod[12 * 8] = // used for .MOD loading/saving
+const uint16_t amigaPeriod[8 * 12] = // used for .MOD loading/saving
 {
 	6848, 6464, 6096, 5760, 5424, 5120, 4832, 4560, 4304, 4064, 3840, 3624,
 	3424, 3232, 3048, 2880, 2712, 2560, 2416, 2280, 2152, 2032, 1920, 1812,

src/ft2_tables.h+3−1

 #define KEY2EFX_ENTRIES (signed)(sizeof (key2EfxTab) / sizeof (SDL_Keycode))
 #define KEY2HEX_ENTRIES (signed)(sizeof (key2HexTab) / sizeof (SDL_Keycode))
+extern const uint16_t ptPeriods[3 * 12];
 extern const uint8_t arpTab[256];
 extern const int8_t vibSineTab[256]; // for auto-vibrato
 extern const uint8_t vibTab[32];
-extern const uint16_t amigaPeriod[12 * 8];
+extern const uint16_t amigaPeriod[8 * 12];
 extern const uint16_t linearPeriods[1936];
 extern const uint16_t amigaPeriods[1936];

src/helpdata/FT2.HLP+13−7

 >- Full screen edit mode.
 >- Improved editing facilities.
-@X040@C001FT2 supports the following file formats:
+@X040@C001The FT2 clone supports the following file formats:
 @X040@C001Modules:
 >@X060@C002
->- Standard modules (15- > 31-instruments). (MOD,NST)
+>- Standard modules (15/31 samples). (MOD,NST,STK)
->- Fasttracker v1.0 2,4,6,8..32-channel formats. (MOD)
+>- Fasttracker II modules. (XM,MOD)
->- ScreamTracker modules. (STM,S3M)
+>- Fasttracker modules. (MOD/FST)
+>
+@X040@C001Experimental module support:
+>@X060@C002
+>- Scream Tracker 3 modules. (S3M)
+>- Scream Tracker 2 modules. (STM)
+>- DIGI Booster (non-Pro) modules. (DIGI)
 >
 @X040@C001Samples:
 >@X060@C002
 >- Gravis Ultrasound Patches, PAT.
 >- SMP/SAM/RAW/SND data files, signed and unsigned.
->- Windows WAV-files.
+>- WAV files.
->- Amiga IFF-files. (Interchange File Format)
+>- Amiga IFF.
->- Apple AIFF-files.
+>- Apple AIFF.
 @X040@C001FT2 introduces several new file formats:
 >@X060@C002

src/helpdata/ft2_help_data.h+2142−2133

 #include <stdint.h>
-#define HELP_DATA_LEN 27371
+#define HELP_DATA_LEN 27476
-const uint8_t helpData[27371] =
+const uint8_t helpData[27476] =
 {
 	0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x64,0x65,0x2E,0x1F,0x3E,0x2D,0x20,0x49,0x6D,0x70,0x72,0x6F,
 	0x76,0x65,0x64,0x20,0x65,0x64,0x69,0x74,0x69,0x6E,0x67,0x20,
 	0x66,0x61,0x63,0x69,0x6C,0x69,0x74,0x69,0x65,0x73,0x2E,0x00,
-	0x32,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x46,
+	0x3C,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x54,
-	0x54,0x32,0x20,0x73,0x75,0x70,0x70,0x6F,0x72,0x74,0x73,0x20,
+	0x68,0x65,0x20,0x46,0x54,0x32,0x20,0x63,0x6C,0x6F,0x6E,0x65,
-	0x74,0x68,0x65,0x20,0x66,0x6F,0x6C,0x6C,0x6F,0x77,0x69,0x6E,
+	0x20,0x73,0x75,0x70,0x70,0x6F,0x72,0x74,0x73,0x20,0x74,0x68,
-	0x67,0x20,0x66,0x69,0x6C,0x65,0x20,0x66,0x6F,0x72,0x6D,0x61,
+	0x65,0x20,0x66,0x6F,0x6C,0x6C,0x6F,0x77,0x69,0x6E,0x67,0x20,
-	0x74,0x73,0x3A,0x00,0x12,0x40,0x58,0x30,0x34,0x30,0x40,0x43,
+	0x66,0x69,0x6C,0x65,0x20,0x66,0x6F,0x72,0x6D,0x61,0x74,0x73,
-	0x30,0x30,0x31,0x4D,0x6F,0x64,0x75,0x6C,0x65,0x73,0x3A,0x0B,
+	0x3A,0x00,0x12,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
-	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x35,
+	0x31,0x4D,0x6F,0x64,0x75,0x6C,0x65,0x73,0x3A,0x0B,0x3E,0x40,
-	0x3E,0x2D,0x20,0x53,0x74,0x61,0x6E,0x64,0x61,0x72,0x64,0x20,
+	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x32,0x3E,0x2D,
-	0x6D,0x6F,0x64,0x75,0x6C,0x65,0x73,0x20,0x28,0x31,0x35,0x2D,
+	0x20,0x53,0x74,0x61,0x6E,0x64,0x61,0x72,0x64,0x20,0x6D,0x6F,
-	0x20,0x3E,0x20,0x33,0x31,0x2D,0x69,0x6E,0x73,0x74,0x72,0x75,
+	0x64,0x75,0x6C,0x65,0x73,0x20,0x28,0x31,0x35,0x2F,0x33,0x31,
-	0x6D,0x65,0x6E,0x74,0x73,0x29,0x2E,0x20,0x28,0x4D,0x4F,0x44,
+	0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x73,0x29,0x2E,0x20,0x28,
-	0x2C,0x4E,0x53,0x54,0x29,0x36,0x3E,0x2D,0x20,0x46,0x61,0x73,
+	0x4D,0x4F,0x44,0x2C,0x4E,0x53,0x54,0x2C,0x53,0x54,0x4B,0x29,
-	0x74,0x74,0x72,0x61,0x63,0x6B,0x65,0x72,0x20,0x76,0x31,0x2E,
+	0x23,0x3E,0x2D,0x20,0x46,0x61,0x73,0x74,0x74,0x72,0x61,0x63,
-	0x30,0x20,0x32,0x2C,0x34,0x2C,0x36,0x2C,0x38,0x2E,0x2E,0x33,
+	0x6B,0x65,0x72,0x20,0x49,0x49,0x20,0x6D,0x6F,0x64,0x75,0x6C,
-	0x32,0x2D,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x20,0x66,0x6F,
+	0x65,0x73,0x2E,0x20,0x28,0x58,0x4D,0x2C,0x4D,0x4F,0x44,0x29,
-	0x72,0x6D,0x61,0x74,0x73,0x2E,0x20,0x28,0x4D,0x4F,0x44,0x29,
+	0x21,0x3E,0x2D,0x20,0x46,0x61,0x73,0x74,0x74,0x72,0x61,0x63,
-	0x23,0x3E,0x2D,0x20,0x53,0x63,0x72,0x65,0x61,0x6D,0x54,0x72,
+	0x6B,0x65,0x72,0x20,0x6D,0x6F,0x64,0x75,0x6C,0x65,0x73,0x2E,
-	0x61,0x63,0x6B,0x65,0x72,0x20,0x6D,0x6F,0x64,0x75,0x6C,0x65,
+	0x20,0x28,0x4D,0x4F,0x44,0x2F,0x46,0x53,0x54,0x29,0x01,0x3E,
-	0x73,0x2E,0x20,0x28,0x53,0x54,0x4D,0x2C,0x53,0x33,0x4D,0x29,
+	0x26,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x45,
-	0x01,0x3E,0x12,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
+	0x78,0x70,0x65,0x72,0x69,0x6D,0x65,0x6E,0x74,0x61,0x6C,0x20,
-	0x31,0x53,0x61,0x6D,0x70,0x6C,0x65,0x73,0x3A,0x0B,0x3E,0x40,
+	0x6D,0x6F,0x64,0x75,0x6C,0x65,0x20,0x73,0x75,0x70,0x70,0x6F,
-	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x22,0x3E,0x2D,
+	0x72,0x74,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
-	0x20,0x47,0x72,0x61,0x76,0x69,0x73,0x20,0x55,0x6C,0x74,0x72,
+	0x30,0x30,0x32,0x22,0x3E,0x2D,0x20,0x53,0x63,0x72,0x65,0x61,
-	0x61,0x73,0x6F,0x75,0x6E,0x64,0x20,0x50,0x61,0x74,0x63,0x68,
+	0x6D,0x20,0x54,0x72,0x61,0x63,0x6B,0x65,0x72,0x20,0x33,0x20,
-	0x65,0x73,0x2C,0x20,0x50,0x41,0x54,0x2E,0x33,0x3E,0x2D,0x20,
+	0x6D,0x6F,0x64,0x75,0x6C,0x65,0x73,0x2E,0x20,0x28,0x53,0x33,
-	0x53,0x4D,0x50,0x2F,0x53,0x41,0x4D,0x2F,0x52,0x41,0x57,0x2F,
+	0x4D,0x29,0x22,0x3E,0x2D,0x20,0x53,0x63,0x72,0x65,0x61,0x6D,
-	0x53,0x4E,0x44,0x20,0x64,0x61,0x74,0x61,0x20,0x66,0x69,0x6C,
+	0x20,0x54,0x72,0x61,0x63,0x6B,0x65,0x72,0x20,0x32,0x20,0x6D,
-	0x65,0x73,0x2C,0x20,0x73,0x69,0x67,0x6E,0x65,0x64,0x20,0x61,
+	0x6F,0x64,0x75,0x6C,0x65,0x73,0x2E,0x20,0x28,0x53,0x54,0x4D,
-	0x6E,0x64,0x20,0x75,0x6E,0x73,0x69,0x67,0x6E,0x65,0x64,0x2E,
+	0x29,0x29,0x3E,0x2D,0x20,0x44,0x49,0x47,0x49,0x20,0x42,0x6F,
-	0x15,0x3E,0x2D,0x20,0x57,0x69,0x6E,0x64,0x6F,0x77,0x73,0x20,
+	0x6F,0x73,0x74,0x65,0x72,0x20,0x28,0x6E,0x6F,0x6E,0x2D,0x50,
-	0x57,0x41,0x56,0x2D,0x66,0x69,0x6C,0x65,0x73,0x2E,0x2D,0x3E,
+	0x72,0x6F,0x29,0x20,0x6D,0x6F,0x64,0x75,0x6C,0x65,0x73,0x2E,
-	0x2D,0x20,0x41,0x6D,0x69,0x67,0x61,0x20,0x49,0x46,0x46,0x2D,
+	0x20,0x28,0x44,0x49,0x47,0x49,0x29,0x01,0x3E,0x12,0x40,0x58,
-	0x66,0x69,0x6C,0x65,0x73,0x2E,0x20,0x28,0x49,0x6E,0x74,0x65,
+	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x61,0x6D,0x70,
-	0x72,0x63,0x68,0x61,0x6E,0x67,0x65,0x20,0x46,0x69,0x6C,0x65,
+	0x6C,0x65,0x73,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x20,0x46,0x6F,0x72,0x6D,0x61,0x74,0x29,0x14,0x3E,0x2D,0x20,
+	0x43,0x30,0x30,0x32,0x22,0x3E,0x2D,0x20,0x47,0x72,0x61,0x76,
-	0x41,0x70,0x70,0x6C,0x65,0x20,0x41,0x49,0x46,0x46,0x2D,0x66,
+	0x69,0x73,0x20,0x55,0x6C,0x74,0x72,0x61,0x73,0x6F,0x75,0x6E,
-	0x69,0x6C,0x65,0x73,0x2E,0x00,0x32,0x40,0x58,0x30,0x34,0x30,
+	0x64,0x20,0x50,0x61,0x74,0x63,0x68,0x65,0x73,0x2C,0x20,0x50,
-	0x40,0x43,0x30,0x30,0x31,0x46,0x54,0x32,0x20,0x69,0x6E,0x74,
+	0x41,0x54,0x2E,0x33,0x3E,0x2D,0x20,0x53,0x4D,0x50,0x2F,0x53,
-	0x72,0x6F,0x64,0x75,0x63,0x65,0x73,0x20,0x73,0x65,0x76,0x65,
+	0x41,0x4D,0x2F,0x52,0x41,0x57,0x2F,0x53,0x4E,0x44,0x20,0x64,
-	0x72,0x61,0x6C,0x20,0x6E,0x65,0x77,0x20,0x66,0x69,0x6C,0x65,
+	0x61,0x74,0x61,0x20,0x66,0x69,0x6C,0x65,0x73,0x2C,0x20,0x73,
-	0x20,0x66,0x6F,0x72,0x6D,0x61,0x74,0x73,0x3A,0x0B,0x3E,0x40,
+	0x69,0x67,0x6E,0x65,0x64,0x20,0x61,0x6E,0x64,0x20,0x75,0x6E,
-	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x1C,0x3E,0x2D,
+	0x73,0x69,0x67,0x6E,0x65,0x64,0x2E,0x0D,0x3E,0x2D,0x20,0x57,
-	0x20,0x58,0x4D,0x20,0x20,0x40,0x54,0x31,0x31,0x30,0x45,0x78,
+	0x41,0x56,0x20,0x66,0x69,0x6C,0x65,0x73,0x2E,0x0D,0x3E,0x2D,
-	0x74,0x65,0x6E,0x64,0x65,0x64,0x20,0x6D,0x6F,0x64,0x75,0x6C,
+	0x20,0x41,0x6D,0x69,0x67,0x61,0x20,0x49,0x46,0x46,0x2E,0x0E,
-	0x65,0x2E,0x20,0x3E,0x2D,0x20,0x58,0x49,0x20,0x20,0x40,0x54,
+	0x3E,0x2D,0x20,0x41,0x70,0x70,0x6C,0x65,0x20,0x41,0x49,0x46,
+	0x46,0x2E,0x00,0x32,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
+	0x30,0x31,0x46,0x54,0x32,0x20,0x69,0x6E,0x74,0x72,0x6F,0x64,
+	0x75,0x63,0x65,0x73,0x20,0x73,0x65,0x76,0x65,0x72,0x61,0x6C,
+	0x20,0x6E,0x65,0x77,0x20,0x66,0x69,0x6C,0x65,0x20,0x66,0x6F,
+	0x72,0x6D,0x61,0x74,0x73,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,
+	0x30,0x40,0x43,0x30,0x30,0x32,0x1C,0x3E,0x2D,0x20,0x58,0x4D,
+	0x20,0x20,0x40,0x54,0x31,0x31,0x30,0x45,0x78,0x74,0x65,0x6E,
+	0x64,0x65,0x64,0x20,0x6D,0x6F,0x64,0x75,0x6C,0x65,0x2E,0x20,
+	0x3E,0x2D,0x20,0x58,0x49,0x20,0x20,0x40,0x54,0x31,0x31,0x30,
+	0x45,0x78,0x74,0x65,0x6E,0x64,0x65,0x64,0x20,0x69,0x6E,0x73,
+	0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x2E,0x1D,0x3E,0x2D,0x20,
+	0x58,0x50,0x20,0x20,0x40,0x54,0x31,0x31,0x30,0x45,0x78,0x74,
+	0x65,0x6E,0x64,0x65,0x64,0x20,0x70,0x61,0x74,0x74,0x65,0x72,
+	0x6E,0x2E,0x1B,0x3E,0x2D,0x20,0x58,0x54,0x20,0x20,0x40,0x54,
 	0x31,0x31,0x30,0x45,0x78,0x74,0x65,0x6E,0x64,0x65,0x64,0x20,
-	0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x2E,0x1D,
+	0x74,0x72,0x61,0x63,0x6B,0x2E,0x00,0x03,0x45,0x4E,0x44,0x4C,
-	0x3E,0x2D,0x20,0x58,0x50,0x20,0x20,0x40,0x54,0x31,0x31,0x30,
+	0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
-	0x45,0x78,0x74,0x65,0x6E,0x64,0x65,0x64,0x20,0x70,0x61,0x74,
-	0x74,0x65,0x72,0x6E,0x2E,0x1B,0x3E,0x2D,0x20,0x58,0x54,0x20,
-	0x20,0x40,0x54,0x31,0x31,0x30,0x45,0x78,0x74,0x65,0x6E,0x64,
-	0x65,0x64,0x20,0x74,0x72,0x61,0x63,0x6B,0x2E,0x00,0x03,0x45,
-	0x4E,0x44,0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
-	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x4C,0x3B,0x2A,0x2A,0x2A,
+	0x2A,0x2A,0x2A,0x2A,0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
-	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
+	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x09,0x40,0x4C,
-	0x09,0x40,0x4C,0x45,0x66,0x66,0x65,0x63,0x74,0x73,0x00,0x18,
+	0x45,0x66,0x66,0x65,0x63,0x74,0x73,0x00,0x18,0x40,0x58,0x30,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x68,
+	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x68,0x6F,0x72,0x74,
-	0x6F,0x72,0x74,0x20,0x73,0x75,0x6D,0x6D,0x61,0x72,0x79,0x3A,
+	0x20,0x73,0x75,0x6D,0x6D,0x61,0x72,0x79,0x3A,0x0B,0x3E,0x40,
-	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
+	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x0B,0x3E,0x30,
-	0x0B,0x3E,0x30,0x20,0x41,0x72,0x70,0x65,0x67,0x67,0x69,0x6F,
+	0x20,0x41,0x72,0x70,0x65,0x67,0x67,0x69,0x6F,0x10,0x3E,0x31,
-	0x10,0x3E,0x31,0x20,0x50,0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,
+	0x20,0x50,0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,
-	0x74,0x6F,0x20,0x75,0x70,0x12,0x3E,0x32,0x20,0x50,0x6F,0x72,
+	0x75,0x70,0x12,0x3E,0x32,0x20,0x50,0x6F,0x72,0x74,0x61,0x6D,
-	0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x64,0x6F,0x77,0x6E,
+	0x65,0x6E,0x74,0x6F,0x20,0x64,0x6F,0x77,0x6E,0x12,0x3E,0x33,
-	0x12,0x3E,0x33,0x20,0x54,0x6F,0x6E,0x65,0x20,0x70,0x6F,0x72,
+	0x20,0x54,0x6F,0x6E,0x65,0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,
-	0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x0A,0x3E,0x34,0x20,0x56,
+	0x65,0x6E,0x74,0x6F,0x0A,0x3E,0x34,0x20,0x56,0x69,0x62,0x72,
-	0x69,0x62,0x72,0x61,0x74,0x6F,0x1C,0x3E,0x35,0x20,0x50,0x6F,
+	0x61,0x74,0x6F,0x1C,0x3E,0x35,0x20,0x50,0x6F,0x72,0x74,0x61,
-	0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x2B,0x20,0x56,
+	0x6D,0x65,0x6E,0x74,0x6F,0x20,0x2B,0x20,0x56,0x6F,0x6C,0x75,
-	0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x19,
+	0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x19,0x3E,0x36,0x20,
-	0x3E,0x36,0x20,0x56,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x2B,
+	0x56,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x2B,0x20,0x56,0x6F,
-	0x20,0x56,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,
+	0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x0A,0x3E,
-	0x65,0x0A,0x3E,0x37,0x20,0x54,0x72,0x65,0x6D,0x6F,0x6C,0x6F,
+	0x37,0x20,0x54,0x72,0x65,0x6D,0x6F,0x6C,0x6F,0x17,0x3E,0x38,
-	0x17,0x3E,0x38,0x20,0x53,0x65,0x74,0x20,0x70,0x61,0x6E,0x6E,
+	0x20,0x53,0x65,0x74,0x20,0x70,0x61,0x6E,0x6E,0x69,0x6E,0x67,
-	0x69,0x6E,0x67,0x20,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,
+	0x20,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x10,0x3E,0x39,
-	0x10,0x3E,0x39,0x20,0x53,0x61,0x6D,0x70,0x6C,0x65,0x20,0x6F,
+	0x20,0x53,0x61,0x6D,0x70,0x6C,0x65,0x20,0x6F,0x66,0x66,0x73,
-	0x66,0x66,0x73,0x65,0x74,0x0F,0x3E,0x41,0x20,0x56,0x6F,0x6C,
+	0x65,0x74,0x0F,0x3E,0x41,0x20,0x56,0x6F,0x6C,0x75,0x6D,0x65,
-	0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x10,0x3E,0x42,
+	0x20,0x73,0x6C,0x69,0x64,0x65,0x10,0x3E,0x42,0x20,0x50,0x6F,
-	0x20,0x50,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x20,0x6A,0x75,
+	0x73,0x69,0x74,0x69,0x6F,0x6E,0x20,0x6A,0x75,0x6D,0x70,0x0D,
-	0x6D,0x70,0x0D,0x3E,0x43,0x20,0x53,0x65,0x74,0x20,0x76,0x6F,
+	0x3E,0x43,0x20,0x53,0x65,0x74,0x20,0x76,0x6F,0x6C,0x75,0x6D,
-	0x6C,0x75,0x6D,0x65,0x10,0x3E,0x44,0x20,0x50,0x61,0x74,0x74,
+	0x65,0x10,0x3E,0x44,0x20,0x50,0x61,0x74,0x74,0x65,0x72,0x6E,
-	0x65,0x72,0x6E,0x20,0x62,0x72,0x65,0x61,0x6B,0x04,0x3E,0x45,
+	0x20,0x62,0x72,0x65,0x61,0x6B,0x04,0x3E,0x45,0x20,0x2B,0x23,
-	0x20,0x2B,0x23,0x3E,0x40,0x58,0x30,0x38,0x30,0x30,0x20,0x46,
+	0x3E,0x40,0x58,0x30,0x38,0x30,0x30,0x20,0x46,0x69,0x6C,0x74,
-	0x69,0x6C,0x74,0x65,0x72,0x20,0x6F,0x6E,0x2F,0x6F,0x66,0x66,
+	0x65,0x72,0x20,0x6F,0x6E,0x2F,0x6F,0x66,0x66,0x20,0x28,0x41,
-	0x20,0x28,0x41,0x6D,0x69,0x67,0x61,0x20,0x6F,0x6E,0x6C,0x79,
+	0x6D,0x69,0x67,0x61,0x20,0x6F,0x6E,0x6C,0x79,0x21,0x29,0x15,
-	0x21,0x29,0x15,0x3E,0x31,0x20,0x46,0x69,0x6E,0x65,0x20,0x70,
+	0x3E,0x31,0x20,0x46,0x69,0x6E,0x65,0x20,0x70,0x6F,0x72,0x74,
-	0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x75,0x70,
+	0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x75,0x70,0x17,0x3E,0x32,
-	0x17,0x3E,0x32,0x20,0x46,0x69,0x6E,0x65,0x20,0x70,0x6F,0x72,
+	0x20,0x46,0x69,0x6E,0x65,0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,
-	0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x64,0x6F,0x77,0x6E,
+	0x65,0x6E,0x74,0x6F,0x20,0x64,0x6F,0x77,0x6E,0x18,0x3E,0x33,
-	0x18,0x3E,0x33,0x20,0x53,0x65,0x74,0x20,0x67,0x6C,0x69,0x73,
+	0x20,0x53,0x65,0x74,0x20,0x67,0x6C,0x69,0x73,0x73,0x61,0x6E,
-	0x73,0x61,0x6E,0x64,0x6F,0x20,0x63,0x6F,0x6E,0x74,0x72,0x6F,
+	0x64,0x6F,0x20,0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x16,0x3E,
-	0x6C,0x16,0x3E,0x34,0x20,0x53,0x65,0x74,0x20,0x76,0x69,0x62,
+	0x34,0x20,0x53,0x65,0x74,0x20,0x76,0x69,0x62,0x72,0x61,0x74,
-	0x72,0x61,0x74,0x6F,0x20,0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,
+	0x6F,0x20,0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x10,0x3E,0x35,
-	0x10,0x3E,0x35,0x20,0x53,0x65,0x74,0x20,0x66,0x69,0x6E,0x65,
+	0x20,0x53,0x65,0x74,0x20,0x66,0x69,0x6E,0x65,0x2D,0x74,0x75,
-	0x2D,0x74,0x75,0x6E,0x65,0x0C,0x3E,0x36,0x20,0x4A,0x75,0x6D,
+	0x6E,0x65,0x0C,0x3E,0x36,0x20,0x4A,0x75,0x6D,0x70,0x20,0x6C,
-	0x70,0x20,0x6C,0x6F,0x6F,0x70,0x16,0x3E,0x37,0x20,0x53,0x65,
+	0x6F,0x6F,0x70,0x16,0x3E,0x37,0x20,0x53,0x65,0x74,0x20,0x74,
-	0x74,0x20,0x74,0x72,0x65,0x6D,0x6F,0x6C,0x6F,0x20,0x63,0x6F,
+	0x72,0x65,0x6D,0x6F,0x6C,0x6F,0x20,0x63,0x6F,0x6E,0x74,0x72,
-	0x6E,0x74,0x72,0x6F,0x6C,0x09,0x3E,0x38,0x20,0x55,0x6E,0x75,
+	0x6F,0x6C,0x09,0x3E,0x38,0x20,0x55,0x6E,0x75,0x73,0x65,0x64,
-	0x73,0x65,0x64,0x0E,0x3E,0x39,0x20,0x52,0x65,0x74,0x72,0x69,
+	0x0E,0x3E,0x39,0x20,0x52,0x65,0x74,0x72,0x69,0x67,0x20,0x6E,
-	0x67,0x20,0x6E,0x6F,0x74,0x65,0x17,0x3E,0x41,0x20,0x46,0x69,
+	0x6F,0x74,0x65,0x17,0x3E,0x41,0x20,0x46,0x69,0x6E,0x65,0x20,
-	0x6E,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,
-	0x69,0x64,0x65,0x20,0x75,0x70,0x19,0x3E,0x42,0x20,0x46,0x69,
-	0x6E,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,
-	0x69,0x64,0x65,0x20,0x64,0x6F,0x77,0x6E,0x0B,0x3E,0x43,0x20,
-	0x4E,0x6F,0x74,0x65,0x20,0x63,0x75,0x74,0x0D,0x3E,0x44,0x20,
-	0x4E,0x6F,0x74,0x65,0x20,0x64,0x65,0x6C,0x61,0x79,0x10,0x3E,
-	0x45,0x20,0x50,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x64,0x65,
-	0x6C,0x61,0x79,0x1D,0x3E,0x46,0x20,0x46,0x75,0x6E,0x6B,0x20,
-	0x69,0x74,0x21,0x20,0x28,0x4E,0x6F,0x74,0x20,0x69,0x6D,0x70,
-	0x6C,0x65,0x6D,0x65,0x6E,0x74,0x65,0x64,0x29,0x06,0x3E,0x40,
-	0x58,0x30,0x36,0x30,0x0B,0x46,0x20,0x53,0x65,0x74,0x20,0x73,
-	0x70,0x65,0x65,0x64,0x14,0x3E,0x47,0x20,0x53,0x65,0x74,0x20,
-	0x67,0x6C,0x6F,0x62,0x61,0x6C,0x20,0x76,0x6F,0x6C,0x75,0x6D,
-	0x65,0x16,0x3E,0x48,0x20,0x47,0x6C,0x6F,0x62,0x61,0x6C,0x20,
 	0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,
-	0x0A,0x3E,0x4B,0x20,0x4B,0x65,0x79,0x20,0x6F,0x66,0x66,0x18,
+	0x20,0x75,0x70,0x19,0x3E,0x42,0x20,0x46,0x69,0x6E,0x65,0x20,
-	0x3E,0x4C,0x20,0x53,0x65,0x74,0x20,0x65,0x6E,0x76,0x65,0x6C,
-	0x6F,0x70,0x65,0x20,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,
-	0x10,0x3E,0x50,0x20,0x50,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,
-	0x73,0x6C,0x69,0x64,0x65,0x14,0x3E,0x52,0x20,0x4D,0x75,0x6C,
-	0x74,0x69,0x20,0x72,0x65,0x74,0x72,0x69,0x67,0x20,0x6E,0x6F,
-	0x74,0x65,0x09,0x3E,0x54,0x20,0x54,0x72,0x65,0x6D,0x6F,0x72,
-	0x04,0x3E,0x58,0x20,0x2B,0x20,0x3E,0x40,0x58,0x30,0x38,0x30,
-	0x31,0x20,0x45,0x78,0x74,0x72,0x61,0x20,0x66,0x69,0x6E,0x65,
-	0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,
-	0x75,0x70,0x1D,0x3E,0x32,0x20,0x45,0x78,0x74,0x72,0x61,0x20,
-	0x66,0x69,0x6E,0x65,0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,0x65,
-	0x6E,0x74,0x6F,0x20,0x64,0x6F,0x77,0x6E,0x00,0x18,0x40,0x58,
-	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x56,0x6F,0x6C,0x75,
-	0x6D,0x65,0x20,0x63,0x6F,0x6C,0x75,0x6D,0x6E,0x3A,0x0B,0x3E,
-	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x17,0x30,
-	0x30,0x2E,0x2E,0x34,0x30,0x20,0x40,0x54,0x31,0x36,0x30,0x53,
-	0x65,0x74,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x2E,0x01,0x3E,
-	0x1A,0x3E,0x2D,0x20,0x40,0x54,0x31,0x36,0x30,0x56,0x6F,0x6C,
-	0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x20,0x64,0x6F,
-	0x77,0x6E,0x2E,0x18,0x3E,0x2B,0x20,0x40,0x54,0x31,0x36,0x30,
-	0x56,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,
-	0x20,0x75,0x70,0x2E,0x35,0x3E,0x44,0x20,0x40,0x54,0x31,0x36,
-	0x30,0x46,0x69,0x6E,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,
-	0x20,0x73,0x6C,0x69,0x64,0x65,0x20,0x64,0x6F,0x77,0x6E,0x2E,
-	0x20,0x28,0x49,0x6E,0x64,0x69,0x63,0x61,0x74,0x65,0x64,0x20,
-	0x62,0x79,0x20,0x73,0x79,0x6D,0x62,0x6F,0x6C,0x29,0x33,0x3E,
-	0x55,0x20,0x40,0x54,0x31,0x36,0x30,0x46,0x69,0x6E,0x65,0x20,
 	0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,
-	0x20,0x75,0x70,0x2E,0x20,0x28,0x49,0x6E,0x64,0x69,0x63,0x61,
+	0x20,0x64,0x6F,0x77,0x6E,0x0B,0x3E,0x43,0x20,0x4E,0x6F,0x74,
-	0x74,0x65,0x64,0x20,0x62,0x79,0x20,0x73,0x79,0x6D,0x62,0x6F,
+	0x65,0x20,0x63,0x75,0x74,0x0D,0x3E,0x44,0x20,0x4E,0x6F,0x74,
-	0x6C,0x29,0x1A,0x3E,0x53,0x20,0x40,0x54,0x31,0x36,0x30,0x53,
+	0x65,0x20,0x64,0x65,0x6C,0x61,0x79,0x10,0x3E,0x45,0x20,0x50,
-	0x65,0x74,0x20,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x73,
+	0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x64,0x65,0x6C,0x61,0x79,
-	0x70,0x65,0x65,0x64,0x2E,0x10,0x3E,0x56,0x20,0x40,0x54,0x31,
+	0x1D,0x3E,0x46,0x20,0x46,0x75,0x6E,0x6B,0x20,0x69,0x74,0x21,
-	0x36,0x30,0x56,0x69,0x62,0x72,0x61,0x74,0x6F,0x2E,0x1D,0x3E,
+	0x20,0x28,0x4E,0x6F,0x74,0x20,0x69,0x6D,0x70,0x6C,0x65,0x6D,
-	0x50,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x65,0x74,0x20,0x70,
+	0x65,0x6E,0x74,0x65,0x64,0x29,0x06,0x3E,0x40,0x58,0x30,0x36,
-	0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x70,0x6F,0x73,0x69,0x74,
+	0x30,0x0B,0x46,0x20,0x53,0x65,0x74,0x20,0x73,0x70,0x65,0x65,
-	0x69,0x6F,0x6E,0x2E,0x32,0x3E,0x52,0x20,0x40,0x54,0x31,0x36,
+	0x64,0x14,0x3E,0x47,0x20,0x53,0x65,0x74,0x20,0x67,0x6C,0x6F,
-	0x30,0x50,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x73,0x6C,0x69,
+	0x62,0x61,0x6C,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x16,0x3E,
-	0x64,0x65,0x20,0x72,0x69,0x67,0x68,0x74,0x2E,0x20,0x28,0x49,
+	0x48,0x20,0x47,0x6C,0x6F,0x62,0x61,0x6C,0x20,0x76,0x6F,0x6C,
+	0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x0A,0x3E,0x4B,
+	0x20,0x4B,0x65,0x79,0x20,0x6F,0x66,0x66,0x18,0x3E,0x4C,0x20,
+	0x53,0x65,0x74,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,
+	0x20,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x10,0x3E,0x50,
+	0x20,0x50,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x73,0x6C,0x69,
+	0x64,0x65,0x14,0x3E,0x52,0x20,0x4D,0x75,0x6C,0x74,0x69,0x20,
+	0x72,0x65,0x74,0x72,0x69,0x67,0x20,0x6E,0x6F,0x74,0x65,0x09,
+	0x3E,0x54,0x20,0x54,0x72,0x65,0x6D,0x6F,0x72,0x04,0x3E,0x58,
+	0x20,0x2B,0x20,0x3E,0x40,0x58,0x30,0x38,0x30,0x31,0x20,0x45,
+	0x78,0x74,0x72,0x61,0x20,0x66,0x69,0x6E,0x65,0x20,0x70,0x6F,
+	0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x75,0x70,0x1D,
+	0x3E,0x32,0x20,0x45,0x78,0x74,0x72,0x61,0x20,0x66,0x69,0x6E,
+	0x65,0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,
+	0x20,0x64,0x6F,0x77,0x6E,0x00,0x18,0x40,0x58,0x30,0x34,0x30,
+	0x40,0x43,0x30,0x30,0x31,0x56,0x6F,0x6C,0x75,0x6D,0x65,0x20,
+	0x63,0x6F,0x6C,0x75,0x6D,0x6E,0x3A,0x0B,0x3E,0x40,0x58,0x30,
+	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x17,0x30,0x30,0x2E,0x2E,
+	0x34,0x30,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x65,0x74,0x20,
+	0x76,0x6F,0x6C,0x75,0x6D,0x65,0x2E,0x01,0x3E,0x1A,0x3E,0x2D,
+	0x20,0x40,0x54,0x31,0x36,0x30,0x56,0x6F,0x6C,0x75,0x6D,0x65,
+	0x20,0x73,0x6C,0x69,0x64,0x65,0x20,0x64,0x6F,0x77,0x6E,0x2E,
+	0x18,0x3E,0x2B,0x20,0x40,0x54,0x31,0x36,0x30,0x56,0x6F,0x6C,
+	0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x20,0x75,0x70,
+	0x2E,0x35,0x3E,0x44,0x20,0x40,0x54,0x31,0x36,0x30,0x46,0x69,
+	0x6E,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,
+	0x69,0x64,0x65,0x20,0x64,0x6F,0x77,0x6E,0x2E,0x20,0x28,0x49,
 	0x6E,0x64,0x69,0x63,0x61,0x74,0x65,0x64,0x20,0x62,0x79,0x20,
-	0x73,0x79,0x6D,0x62,0x6F,0x6C,0x29,0x31,0x3E,0x4C,0x20,0x40,
+	0x73,0x79,0x6D,0x62,0x6F,0x6C,0x29,0x33,0x3E,0x55,0x20,0x40,
-	0x54,0x31,0x36,0x30,0x50,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,
+	0x54,0x31,0x36,0x30,0x46,0x69,0x6E,0x65,0x20,0x76,0x6F,0x6C,
-	0x73,0x6C,0x69,0x64,0x65,0x20,0x6C,0x65,0x66,0x74,0x2E,0x20,
+	0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x20,0x75,0x70,
-	0x28,0x49,0x6E,0x64,0x69,0x63,0x61,0x74,0x65,0x64,0x20,0x62,
+	0x2E,0x20,0x28,0x49,0x6E,0x64,0x69,0x63,0x61,0x74,0x65,0x64,
-	0x79,0x20,0x73,0x79,0x6D,0x62,0x6F,0x6C,0x29,0x18,0x3E,0x4D,
+	0x20,0x62,0x79,0x20,0x73,0x79,0x6D,0x62,0x6F,0x6C,0x29,0x1A,
-	0x20,0x40,0x54,0x31,0x36,0x30,0x54,0x6F,0x6E,0x65,0x20,0x70,
+	0x3E,0x53,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x65,0x74,0x20,
-	0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x2E,0x00,0x00,
+	0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x73,0x70,0x65,0x65,
-	0x1B,0x40,0x4C,0x40,0x58,0x30,0x30,0x30,0x44,0x65,0x74,0x61,
+	0x64,0x2E,0x10,0x3E,0x56,0x20,0x40,0x54,0x31,0x36,0x30,0x56,
-	0x69,0x6C,0x65,0x64,0x20,0x69,0x6E,0x66,0x6F,0x72,0x6D,0x61,
+	0x69,0x62,0x72,0x61,0x74,0x6F,0x2E,0x1D,0x3E,0x50,0x20,0x40,
-	0x74,0x69,0x6F,0x6E,0x00,0x12,0x40,0x58,0x30,0x34,0x30,0x40,
+	0x54,0x31,0x36,0x30,0x53,0x65,0x74,0x20,0x70,0x61,0x6E,0x6E,
-	0x43,0x30,0x30,0x31,0x41,0x72,0x70,0x65,0x67,0x67,0x69,0x6F,
+	0x69,0x6E,0x67,0x20,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,
-	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
+	0x2E,0x32,0x3E,0x52,0x20,0x40,0x54,0x31,0x36,0x30,0x50,0x61,
-	0x27,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x30,0x20,0x2B,
+	0x6E,0x6E,0x69,0x6E,0x67,0x20,0x73,0x6C,0x69,0x64,0x65,0x20,
-	0x20,0x31,0x73,0x74,0x20,0x68,0x61,0x6C,0x66,0x74,0x6F,0x6E,
+	0x72,0x69,0x67,0x68,0x74,0x2E,0x20,0x28,0x49,0x6E,0x64,0x69,
-	0x65,0x20,0x2B,0x20,0x32,0x6E,0x64,0x20,0x68,0x61,0x6C,0x66,
+	0x63,0x61,0x74,0x65,0x64,0x20,0x62,0x79,0x20,0x73,0x79,0x6D,
-	0x74,0x6F,0x6E,0x65,0x00,0x0D,0x45,0x78,0x2E,0x3A,0x20,0x43,
+	0x62,0x6F,0x6C,0x29,0x31,0x3E,0x4C,0x20,0x40,0x54,0x31,0x36,
-	0x2D,0x31,0x20,0x20,0x30,0x33,0x37,0x00,0x16,0x3E,0x31,0x30,
+	0x30,0x50,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x73,0x6C,0x69,
-	0x20,0x50,0x6C,0x61,0x79,0x73,0x20,0x43,0x2D,0x31,0x20,0x74,
+	0x64,0x65,0x20,0x6C,0x65,0x66,0x74,0x2E,0x20,0x28,0x49,0x6E,
-	0x69,0x63,0x6B,0x20,0x23,0x31,0x2E,0x26,0x3E,0x32,0x30,0x20,
+	0x64,0x69,0x63,0x61,0x74,0x65,0x64,0x20,0x62,0x79,0x20,0x73,
+	0x79,0x6D,0x62,0x6F,0x6C,0x29,0x18,0x3E,0x4D,0x20,0x40,0x54,
+	0x31,0x36,0x30,0x54,0x6F,0x6E,0x65,0x20,0x70,0x6F,0x72,0x74,
+	0x61,0x6D,0x65,0x6E,0x74,0x6F,0x2E,0x00,0x00,0x1B,0x40,0x4C,
+	0x40,0x58,0x30,0x30,0x30,0x44,0x65,0x74,0x61,0x69,0x6C,0x65,
+	0x64,0x20,0x69,0x6E,0x66,0x6F,0x72,0x6D,0x61,0x74,0x69,0x6F,
+	0x6E,0x00,0x12,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
+	0x31,0x41,0x72,0x70,0x65,0x67,0x67,0x69,0x6F,0x0B,0x3E,0x40,
+	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x27,0x53,0x79,
+	0x6E,0x74,0x61,0x78,0x3A,0x20,0x30,0x20,0x2B,0x20,0x31,0x73,
+	0x74,0x20,0x68,0x61,0x6C,0x66,0x74,0x6F,0x6E,0x65,0x20,0x2B,
+	0x20,0x32,0x6E,0x64,0x20,0x68,0x61,0x6C,0x66,0x74,0x6F,0x6E,
+	0x65,0x00,0x0D,0x45,0x78,0x2E,0x3A,0x20,0x43,0x2D,0x31,0x20,
+	0x20,0x30,0x33,0x37,0x00,0x16,0x3E,0x31,0x30,0x20,0x50,0x6C,
+	0x61,0x79,0x73,0x20,0x43,0x2D,0x31,0x20,0x74,0x69,0x63,0x6B,
+	0x20,0x23,0x31,0x2E,0x26,0x3E,0x32,0x30,0x20,0x50,0x6C,0x61,
+	0x79,0x73,0x20,0x43,0x2D,0x31,0x20,0x2B,0x20,0x33,0x20,0x4E,
+	0x6F,0x74,0x65,0x73,0x20,0x3D,0x20,0x44,0x23,0x31,0x20,0x74,
+	0x69,0x63,0x6B,0x20,0x23,0x32,0x2E,0x26,0x3E,0x33,0x30,0x20,
 	0x50,0x6C,0x61,0x79,0x73,0x20,0x43,0x2D,0x31,0x20,0x2B,0x20,
-	0x33,0x20,0x4E,0x6F,0x74,0x65,0x73,0x20,0x3D,0x20,0x44,0x23,
+	0x37,0x20,0x4E,0x6F,0x74,0x65,0x73,0x20,0x3D,0x20,0x47,0x2D,
-	0x31,0x20,0x74,0x69,0x63,0x6B,0x20,0x23,0x32,0x2E,0x26,0x3E,
+	0x31,0x20,0x74,0x69,0x63,0x6B,0x20,0x23,0x33,0x2E,0x0B,0x3E,
-	0x33,0x30,0x20,0x50,0x6C,0x61,0x79,0x73,0x20,0x43,0x2D,0x31,
+	0x34,0x30,0x20,0x47,0x6F,0x74,0x6F,0x20,0x31,0x30,0x00,0x1C,
-	0x20,0x2B,0x20,0x37,0x20,0x4E,0x6F,0x74,0x65,0x73,0x20,0x3D,
+	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x50,0x6F,
-	0x20,0x47,0x2D,0x31,0x20,0x74,0x69,0x63,0x6B,0x20,0x23,0x33,
+	0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x75,0x70,0x2F,
-	0x2E,0x0B,0x3E,0x34,0x30,0x20,0x47,0x6F,0x74,0x6F,0x20,0x31,
+	0x64,0x6F,0x77,0x6E,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x30,0x00,0x1C,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
+	0x43,0x30,0x30,0x32,0x18,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,
-	0x31,0x50,0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,
+	0x20,0x28,0x31,0x20,0x6F,0x72,0x20,0x32,0x29,0x20,0x2B,0x20,
-	0x75,0x70,0x2F,0x64,0x6F,0x77,0x6E,0x0B,0x3E,0x40,0x58,0x30,
+	0x53,0x70,0x65,0x65,0x64,0x00,0x40,0x50,0x6F,0x72,0x74,0x61,
-	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x18,0x53,0x79,0x6E,0x74,
+	0x6D,0x65,0x6E,0x74,0x6F,0x20,0x69,0x73,0x20,0x75,0x73,0x65,
-	0x61,0x78,0x3A,0x20,0x28,0x31,0x20,0x6F,0x72,0x20,0x32,0x29,
+	0x64,0x20,0x74,0x6F,0x20,0x73,0x6C,0x69,0x64,0x65,0x20,0x74,
-	0x20,0x2B,0x20,0x53,0x70,0x65,0x65,0x64,0x00,0x40,0x50,0x6F,
+	0x68,0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x70,0x69,
-	0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x69,0x73,0x20,
+	0x74,0x63,0x68,0x20,0x75,0x70,0x20,0x6F,0x72,0x20,0x64,0x6F,
-	0x75,0x73,0x65,0x64,0x20,0x74,0x6F,0x20,0x73,0x6C,0x69,0x64,
+	0x77,0x6E,0x2E,0x20,0x54,0x68,0x69,0x73,0x20,0x69,0x73,0x42,
-	0x65,0x20,0x74,0x68,0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,
+	0x64,0x6F,0x6E,0x65,0x20,0x75,0x73,0x69,0x6E,0x67,0x20,0x74,
-	0x20,0x70,0x69,0x74,0x63,0x68,0x20,0x75,0x70,0x20,0x6F,0x72,
+	0x68,0x65,0x20,0x70,0x65,0x72,0x69,0x6F,0x64,0x20,0x76,0x61,
-	0x20,0x64,0x6F,0x77,0x6E,0x2E,0x20,0x54,0x68,0x69,0x73,0x20,
+	0x6C,0x75,0x65,0x2E,0x20,0x49,0x66,0x20,0x41,0x6D,0x69,0x67,
-	0x69,0x73,0x42,0x64,0x6F,0x6E,0x65,0x20,0x75,0x73,0x69,0x6E,
+	0x61,0x20,0x66,0x72,0x65,0x71,0x75,0x65,0x6E,0x63,0x79,0x20,
-	0x67,0x20,0x74,0x68,0x65,0x20,0x70,0x65,0x72,0x69,0x6F,0x64,
+	0x74,0x61,0x62,0x6C,0x65,0x20,0x69,0x73,0x20,0x75,0x73,0x65,
-	0x20,0x76,0x61,0x6C,0x75,0x65,0x2E,0x20,0x49,0x66,0x20,0x41,
+	0x64,0x2C,0x20,0x74,0x68,0x65,0x40,0x73,0x6C,0x69,0x64,0x69,
-	0x6D,0x69,0x67,0x61,0x20,0x66,0x72,0x65,0x71,0x75,0x65,0x6E,
+	0x6E,0x67,0x20,0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x6E,
-	0x63,0x79,0x20,0x74,0x61,0x62,0x6C,0x65,0x20,0x69,0x73,0x20,
+	0x6F,0x6E,0x2D,0x6C,0x69,0x6E,0x65,0x61,0x72,0x20,0x28,0x74,
-	0x75,0x73,0x65,0x64,0x2C,0x20,0x74,0x68,0x65,0x40,0x73,0x6C,
+	0x68,0x65,0x20,0x73,0x70,0x65,0x65,0x64,0x20,0x64,0x65,0x70,
-	0x69,0x64,0x69,0x6E,0x67,0x20,0x77,0x69,0x6C,0x6C,0x20,0x62,
+	0x65,0x6E,0x64,0x73,0x20,0x6F,0x6E,0x20,0x74,0x68,0x65,0x20,
-	0x65,0x20,0x6E,0x6F,0x6E,0x2D,0x6C,0x69,0x6E,0x65,0x61,0x72,
+	0x66,0x72,0x65,0x71,0x75,0x65,0x6E,0x63,0x79,0x29,0x2E,0x00,
-	0x20,0x28,0x74,0x68,0x65,0x20,0x73,0x70,0x65,0x65,0x64,0x20,
+	0x19,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x54,
-	0x64,0x65,0x70,0x65,0x6E,0x64,0x73,0x20,0x6F,0x6E,0x20,0x74,
+	0x6F,0x6E,0x65,0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,
-	0x68,0x65,0x20,0x66,0x72,0x65,0x71,0x75,0x65,0x6E,0x63,0x79,
+	0x74,0x6F,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
-	0x29,0x2E,0x00,0x19,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
+	0x30,0x32,0x11,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x33,
-	0x30,0x31,0x54,0x6F,0x6E,0x65,0x20,0x70,0x6F,0x72,0x74,0x61,
+	0x20,0x2B,0x20,0x53,0x70,0x65,0x65,0x64,0x00,0x40,0x54,0x68,
-	0x6D,0x65,0x6E,0x74,0x6F,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,
+	0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x69,
-	0x40,0x43,0x30,0x30,0x32,0x11,0x53,0x79,0x6E,0x74,0x61,0x78,
+	0x73,0x20,0x75,0x73,0x65,0x64,0x20,0x74,0x6F,0x67,0x65,0x74,
-	0x3A,0x20,0x33,0x20,0x2B,0x20,0x53,0x70,0x65,0x65,0x64,0x00,
+	0x68,0x65,0x72,0x20,0x77,0x69,0x74,0x68,0x20,0x61,0x20,0x6E,
-	0x40,0x54,0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,
+	0x6F,0x74,0x65,0x2C,0x20,0x61,0x6E,0x64,0x20,0x77,0x69,0x6C,
-	0x64,0x20,0x69,0x73,0x20,0x75,0x73,0x65,0x64,0x20,0x74,0x6F,
+	0x6C,0x20,0x73,0x6C,0x69,0x64,0x65,0x20,0x74,0x6F,0x20,0x69,
-	0x67,0x65,0x74,0x68,0x65,0x72,0x20,0x77,0x69,0x74,0x68,0x20,
+	0x74,0x73,0x43,0x66,0x72,0x65,0x71,0x75,0x65,0x6E,0x63,0x79,
-	0x61,0x20,0x6E,0x6F,0x74,0x65,0x2C,0x20,0x61,0x6E,0x64,0x20,
+	0x2E,0x20,0x49,0x66,0x20,0x67,0x6C,0x69,0x73,0x73,0x61,0x6E,
-	0x77,0x69,0x6C,0x6C,0x20,0x73,0x6C,0x69,0x64,0x65,0x20,0x74,
+	0x64,0x6F,0x20,0x28,0x45,0x33,0x29,0x20,0x69,0x73,0x20,0x75,
-	0x6F,0x20,0x69,0x74,0x73,0x43,0x66,0x72,0x65,0x71,0x75,0x65,
+	0x73,0x65,0x64,0x2C,0x20,0x74,0x68,0x65,0x20,0x66,0x72,0x65,
-	0x6E,0x63,0x79,0x2E,0x20,0x49,0x66,0x20,0x67,0x6C,0x69,0x73,
+	0x71,0x75,0x65,0x6E,0x63,0x79,0x20,0x77,0x69,0x6C,0x6C,0x20,
-	0x73,0x61,0x6E,0x64,0x6F,0x20,0x28,0x45,0x33,0x29,0x20,0x69,
+	0x62,0x65,0x20,0x72,0x6F,0x75,0x6E,0x64,0x65,0x64,0x18,0x74,
-	0x73,0x20,0x75,0x73,0x65,0x64,0x2C,0x20,0x74,0x68,0x65,0x20,
+	0x6F,0x20,0x74,0x68,0x65,0x20,0x6E,0x65,0x61,0x72,0x65,0x73,
-	0x66,0x72,0x65,0x71,0x75,0x65,0x6E,0x63,0x79,0x20,0x77,0x69,
+	0x74,0x20,0x68,0x61,0x6C,0x66,0x74,0x6F,0x6E,0x65,0x2E,0x00,
-	0x6C,0x6C,0x20,0x62,0x65,0x20,0x72,0x6F,0x75,0x6E,0x64,0x65,
+	0x11,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x56,
-	0x64,0x18,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x6E,0x65,0x61,
+	0x69,0x62,0x72,0x61,0x74,0x6F,0x0B,0x3E,0x40,0x58,0x30,0x36,
-	0x72,0x65,0x73,0x74,0x20,0x68,0x61,0x6C,0x66,0x74,0x6F,0x6E,
+	0x30,0x40,0x43,0x30,0x30,0x32,0x18,0x53,0x79,0x6E,0x74,0x61,
-	0x65,0x2E,0x00,0x11,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
+	0x78,0x3A,0x20,0x34,0x20,0x2B,0x20,0x52,0x61,0x74,0x65,0x20,
-	0x30,0x31,0x56,0x69,0x62,0x72,0x61,0x74,0x6F,0x0B,0x3E,0x40,
+	0x2B,0x20,0x44,0x65,0x70,0x74,0x68,0x00,0x3E,0x41,0x64,0x64,
-	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x18,0x53,0x79,
+	0x73,0x20,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x74,0x6F,
-	0x6E,0x74,0x61,0x78,0x3A,0x20,0x34,0x20,0x2B,0x20,0x52,0x61,
+	0x20,0x74,0x68,0x65,0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,
-	0x74,0x65,0x20,0x2B,0x20,0x44,0x65,0x70,0x74,0x68,0x00,0x3E,
+	0x20,0x77,0x69,0x74,0x68,0x20,0x61,0x20,0x72,0x61,0x74,0x65,
-	0x41,0x64,0x64,0x73,0x20,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,
+	0x20,0x61,0x6E,0x64,0x20,0x73,0x70,0x65,0x65,0x64,0x2E,0x20,
-	0x20,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x63,0x68,0x61,0x6E,
+	0x53,0x65,0x74,0x20,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x3D,
-	0x6E,0x65,0x6C,0x20,0x77,0x69,0x74,0x68,0x20,0x61,0x20,0x72,
+	0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x20,0x28,0x45,0x34,0x29,
-	0x61,0x74,0x65,0x20,0x61,0x6E,0x64,0x20,0x73,0x70,0x65,0x65,
+	0x20,0x63,0x61,0x6E,0x20,0x62,0x65,0x20,0x75,0x73,0x65,0x64,
-	0x64,0x2E,0x20,0x53,0x65,0x74,0x20,0x76,0x69,0x62,0x72,0x61,
+	0x20,0x74,0x6F,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x20,0x74,
-	0x74,0x6F,0x3D,0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x20,0x28,
+	0x68,0x65,0x20,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x77,
-	0x45,0x34,0x29,0x20,0x63,0x61,0x6E,0x20,0x62,0x65,0x20,0x75,
+	0x61,0x76,0x65,0x20,0x66,0x6F,0x72,0x6D,0x20,0x28,0x73,0x65,
-	0x73,0x65,0x64,0x20,0x74,0x6F,0x20,0x63,0x68,0x61,0x6E,0x67,
+	0x65,0x07,0x62,0x65,0x6C,0x6F,0x77,0x29,0x2E,0x00,0x28,0x40,
-	0x65,0x20,0x74,0x68,0x65,0x20,0x76,0x69,0x62,0x72,0x61,0x74,
+	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x54,0x6F,0x6E,
-	0x6F,0x20,0x77,0x61,0x76,0x65,0x20,0x66,0x6F,0x72,0x6D,0x20,
-	0x28,0x73,0x65,0x65,0x07,0x62,0x65,0x6C,0x6F,0x77,0x29,0x2E,
-	0x00,0x28,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
-	0x54,0x6F,0x6E,0x65,0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,0x65,
-	0x6E,0x74,0x6F,0x20,0x2B,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,
-	0x20,0x73,0x6C,0x69,0x64,0x65,0x0B,0x3E,0x40,0x58,0x30,0x36,
-	0x30,0x40,0x43,0x30,0x30,0x32,0x11,0x53,0x79,0x6E,0x74,0x61,
-	0x78,0x3A,0x20,0x35,0x20,0x2B,0x20,0x53,0x70,0x65,0x65,0x64,
-	0x00,0x40,0x54,0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,
-	0x6E,0x64,0x20,0x77,0x69,0x6C,0x6C,0x20,0x65,0x78,0x65,0x63,
-	0x75,0x74,0x65,0x20,0x62,0x6F,0x74,0x68,0x20,0x74,0x6F,0x6E,
 	0x65,0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,
-	0x20,0x61,0x6E,0x64,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,
+	0x20,0x2B,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,
-	0x73,0x6C,0x69,0x64,0x65,0x2E,0x27,0x54,0x68,0x65,0x20,0x73,
+	0x69,0x64,0x65,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
-	0x70,0x65,0x65,0x64,0x20,0x69,0x73,0x20,0x75,0x73,0x65,0x64,
+	0x30,0x30,0x32,0x11,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,
-	0x20,0x66,0x6F,0x72,0x20,0x74,0x68,0x65,0x20,0x76,0x6F,0x6C,
+	0x35,0x20,0x2B,0x20,0x53,0x70,0x65,0x65,0x64,0x00,0x40,0x54,
-	0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x2E,0x00,0x20,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x56,0x69,
-	0x62,0x72,0x61,0x74,0x6F,0x20,0x2B,0x20,0x76,0x6F,0x6C,0x75,
-	0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x0B,0x3E,0x40,0x58,
-	0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x11,0x53,0x79,0x6E,
-	0x74,0x61,0x78,0x3A,0x20,0x36,0x20,0x2B,0x20,0x53,0x70,0x65,
-	0x65,0x64,0x00,0x3C,0x54,0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,
-	0x6D,0x61,0x6E,0x64,0x20,0x77,0x69,0x6C,0x6C,0x20,0x65,0x78,
-	0x65,0x63,0x75,0x74,0x65,0x20,0x62,0x6F,0x74,0x68,0x20,0x76,
-	0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x61,0x6E,0x64,0x20,0x76,
-	0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x2E,
-	0x20,0x54,0x68,0x65,0x23,0x73,0x70,0x65,0x65,0x64,0x20,0x69,
-	0x73,0x20,0x75,0x73,0x65,0x64,0x20,0x66,0x6F,0x72,0x20,0x74,
-	0x68,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,
-	0x69,0x64,0x65,0x2E,0x00,0x11,0x40,0x58,0x30,0x34,0x30,0x40,
-	0x43,0x30,0x30,0x31,0x54,0x72,0x65,0x6D,0x6F,0x6C,0x6F,0x0B,
-	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x18,
-	0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x37,0x20,0x2B,0x20,
-	0x52,0x61,0x74,0x65,0x20,0x2B,0x20,0x44,0x65,0x70,0x74,0x68,
-	0x00,0x41,0x54,0x72,0x65,0x6D,0x6F,0x6C,0x6F,0x20,0x61,0x64,
-	0x64,0x73,0x20,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x74,
-	0x6F,0x20,0x74,0x68,0x65,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,
-	0x74,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x2E,0x20,0x54,0x68,
-	0x65,0x20,0x73,0x79,0x6E,0x74,0x61,0x78,0x20,0x69,0x73,0x20,
-	0x65,0x78,0x61,0x63,0x74,0x6C,0x79,0x1B,0x61,0x73,0x20,0x66,
-	0x6F,0x72,0x20,0x74,0x68,0x65,0x20,0x76,0x69,0x62,0x72,0x61,
-	0x74,0x6F,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x2E,0x00,
-	0x1E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,
-	0x65,0x74,0x20,0x70,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x70,
-	0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x0B,0x3E,0x40,0x58,0x30,
-	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x14,0x53,0x79,0x6E,0x74,
-	0x61,0x78,0x3A,0x20,0x38,0x20,0x2B,0x20,0x50,0x6F,0x73,0x69,
-	0x74,0x69,0x6F,0x6E,0x00,0x3E,0x53,0x65,0x74,0x73,0x20,0x74,
-	0x68,0x65,0x20,0x70,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x70,
-	0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x20,0x66,0x6F,0x72,0x20,
-	0x74,0x68,0x65,0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x2E,
-	0x20,0x24,0x30,0x30,0x20,0x69,0x73,0x20,0x74,0x68,0x65,0x20,
-	0x6C,0x65,0x66,0x74,0x6D,0x6F,0x73,0x74,0x3F,0x70,0x6F,0x73,
-	0x69,0x74,0x69,0x6F,0x6E,0x20,0x61,0x6E,0x64,0x20,0x24,0x46,
-	0x46,0x20,0x74,0x68,0x65,0x20,0x72,0x69,0x67,0x68,0x74,0x6D,
-	0x6F,0x73,0x74,0x2E,0x20,0x4E,0x6F,0x74,0x65,0x20,0x74,0x68,
-	0x61,0x74,0x20,0x73,0x6F,0x6D,0x65,0x20,0x73,0x6F,0x75,0x6E,
-	0x64,0x20,0x63,0x61,0x72,0x64,0x73,0x20,0x28,0x65,0x78,0x2E,
-	0x30,0x47,0x55,0x53,0x29,0x20,0x63,0x61,0x6E,0x27,0x74,0x20,
-	0x75,0x73,0x65,0x20,0x61,0x73,0x20,0x6D,0x61,0x6E,0x79,0x20,
-	0x61,0x73,0x20,0x32,0x35,0x36,0x20,0x70,0x61,0x6E,0x6E,0x69,
-	0x6E,0x67,0x20,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x73,
-	0x2E,0x00,0x17,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
-	0x31,0x53,0x61,0x6D,0x70,0x6C,0x65,0x20,0x6F,0x66,0x66,0x73,
-	0x65,0x74,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
-	0x30,0x32,0x12,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x39,
-	0x20,0x2B,0x20,0x4F,0x66,0x66,0x73,0x65,0x74,0x00,0x41,0x54,
 	0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,
-	0x73,0x68,0x6F,0x75,0x6C,0x64,0x20,0x62,0x65,0x20,0x75,0x73,
+	0x77,0x69,0x6C,0x6C,0x20,0x65,0x78,0x65,0x63,0x75,0x74,0x65,
-	0x65,0x64,0x20,0x74,0x6F,0x67,0x65,0x74,0x68,0x65,0x72,0x20,
+	0x20,0x62,0x6F,0x74,0x68,0x20,0x74,0x6F,0x6E,0x65,0x20,0x70,
-	0x77,0x69,0x74,0x68,0x20,0x61,0x20,0x6E,0x6F,0x74,0x65,0x2E,
+	0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x61,0x6E,
-	0x20,0x54,0x68,0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,
+	0x64,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,
-	0x77,0x69,0x6C,0x6C,0x2D,0x62,0x65,0x20,0x70,0x6C,0x61,0x79,
+	0x64,0x65,0x2E,0x27,0x54,0x68,0x65,0x20,0x73,0x70,0x65,0x65,
-	0x65,0x64,0x20,0x66,0x72,0x6F,0x6D,0x20,0x28,0x4F,0x66,0x66,
+	0x64,0x20,0x69,0x73,0x20,0x75,0x73,0x65,0x64,0x20,0x66,0x6F,
-	0x73,0x65,0x74,0x2A,0x24,0x31,0x30,0x30,0x29,0x20,0x69,0x6E,
+	0x72,0x20,0x74,0x68,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,
-	0x73,0x74,0x65,0x61,0x64,0x20,0x6F,0x66,0x20,0x7A,0x65,0x72,
+	0x20,0x73,0x6C,0x69,0x64,0x65,0x2E,0x00,0x20,0x40,0x58,0x30,
-	0x6F,0x2E,0x00,0x16,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
+	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x56,0x69,0x62,0x72,0x61,
-	0x30,0x31,0x56,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,
+	0x74,0x6F,0x20,0x2B,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,
-	0x64,0x65,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
+	0x73,0x6C,0x69,0x64,0x65,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,
-	0x30,0x32,0x21,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x41,
+	0x40,0x43,0x30,0x30,0x32,0x11,0x53,0x79,0x6E,0x74,0x61,0x78,
-	0x20,0x2B,0x20,0x55,0x70,0x20,0x73,0x70,0x65,0x65,0x64,0x20,
+	0x3A,0x20,0x36,0x20,0x2B,0x20,0x53,0x70,0x65,0x65,0x64,0x00,
-	0x2B,0x20,0x44,0x6F,0x77,0x6E,0x20,0x73,0x70,0x65,0x65,0x64,
+	0x3C,0x54,0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,
-	0x00,0x3D,0x53,0x6C,0x69,0x64,0x65,0x73,0x20,0x74,0x68,0x65,
+	0x64,0x20,0x77,0x69,0x6C,0x6C,0x20,0x65,0x78,0x65,0x63,0x75,
-	0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x76,0x6F,0x6C,
+	0x74,0x65,0x20,0x62,0x6F,0x74,0x68,0x20,0x76,0x69,0x62,0x72,
-	0x75,0x6D,0x65,0x20,0x75,0x70,0x20,0x6F,0x72,0x20,0x64,0x6F,
+	0x61,0x74,0x6F,0x20,0x61,0x6E,0x64,0x20,0x76,0x6F,0x6C,0x75,
-	0x77,0x6E,0x2E,0x20,0x45,0x69,0x74,0x68,0x65,0x72,0x20,0x75,
+	0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x2E,0x20,0x54,0x68,
-	0x70,0x20,0x73,0x70,0x65,0x65,0x64,0x20,0x6F,0x72,0x20,0x64,
+	0x65,0x23,0x73,0x70,0x65,0x65,0x64,0x20,0x69,0x73,0x20,0x75,
-	0x6F,0x77,0x6E,0x15,0x73,0x70,0x65,0x65,0x64,0x20,0x73,0x68,
+	0x73,0x65,0x64,0x20,0x66,0x6F,0x72,0x20,0x74,0x68,0x65,0x20,
-	0x6F,0x75,0x6C,0x64,0x20,0x62,0x65,0x20,0x7A,0x65,0x72,0x6F,
+	0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,
-	0x2E,0x00,0x17,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
+	0x2E,0x00,0x11,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
-	0x31,0x50,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x20,0x6A,0x75,
+	0x31,0x54,0x72,0x65,0x6D,0x6F,0x6C,0x6F,0x0B,0x3E,0x40,0x58,
-	0x6D,0x70,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
+	0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x18,0x53,0x79,0x6E,
-	0x30,0x32,0x14,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x42,
+	0x74,0x61,0x78,0x3A,0x20,0x37,0x20,0x2B,0x20,0x52,0x61,0x74,
-	0x20,0x2B,0x20,0x50,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x00,
+	0x65,0x20,0x2B,0x20,0x44,0x65,0x70,0x74,0x68,0x00,0x41,0x54,
-	0x41,0x54,0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,
+	0x72,0x65,0x6D,0x6F,0x6C,0x6F,0x20,0x61,0x64,0x64,0x73,0x20,
-	0x64,0x20,0x77,0x69,0x6C,0x6C,0x20,0x6A,0x75,0x6D,0x70,0x20,
+	0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x74,0x6F,0x20,0x74,
-	0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x73,0x65,0x6C,0x65,0x63,
+	0x68,0x65,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x76,
-	0x74,0x65,0x64,0x20,0x73,0x6F,0x6E,0x67,0x20,0x70,0x6F,0x73,
+	0x6F,0x6C,0x75,0x6D,0x65,0x2E,0x20,0x54,0x68,0x65,0x20,0x73,
-	0x69,0x74,0x69,0x6F,0x6E,0x20,0x61,0x6E,0x64,0x20,0x70,0x6C,
+	0x79,0x6E,0x74,0x61,0x78,0x20,0x69,0x73,0x20,0x65,0x78,0x61,
-	0x61,0x79,0x20,0x74,0x68,0x65,0x1B,0x70,0x61,0x74,0x74,0x65,
+	0x63,0x74,0x6C,0x79,0x1B,0x61,0x73,0x20,0x66,0x6F,0x72,0x20,
-	0x72,0x6E,0x20,0x66,0x72,0x6F,0x6D,0x20,0x74,0x68,0x65,0x20,
+	0x74,0x68,0x65,0x20,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,
-	0x62,0x65,0x67,0x69,0x6E,0x6E,0x69,0x6E,0x67,0x2E,0x00,0x14,
+	0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x2E,0x00,0x1E,0x40,0x58,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x65,
+	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x65,0x74,0x20,
-	0x74,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x0B,0x3E,0x40,0x58,
+	0x70,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x70,0x6F,0x73,0x69,
-	0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x12,0x53,0x79,0x6E,
+	0x74,0x69,0x6F,0x6E,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x74,0x61,0x78,0x3A,0x20,0x43,0x20,0x2B,0x20,0x56,0x6F,0x6C,
+	0x43,0x30,0x30,0x32,0x14,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,
-	0x75,0x6D,0x65,0x00,0x3E,0x53,0x65,0x74,0x73,0x20,0x74,0x68,
+	0x20,0x38,0x20,0x2B,0x20,0x50,0x6F,0x73,0x69,0x74,0x69,0x6F,
-	0x65,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x76,0x6F,
+	0x6E,0x00,0x3E,0x53,0x65,0x74,0x73,0x20,0x74,0x68,0x65,0x20,
-	0x6C,0x75,0x6D,0x65,0x2E,0x20,0x54,0x68,0x65,0x20,0x76,0x6F,
+	0x70,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x70,0x6F,0x73,0x69,
-	0x6C,0x75,0x6D,0x65,0x20,0x73,0x68,0x6F,0x75,0x6C,0x64,0x20,
+	0x74,0x69,0x6F,0x6E,0x20,0x66,0x6F,0x72,0x20,0x74,0x68,0x65,
-	0x6E,0x6F,0x74,0x20,0x62,0x65,0x20,0x67,0x72,0x65,0x61,0x74,
+	0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x2E,0x20,0x24,0x30,
-	0x65,0x72,0x20,0x74,0x68,0x61,0x6E,0x04,0x24,0x34,0x30,0x2E,
+	0x30,0x20,0x69,0x73,0x20,0x74,0x68,0x65,0x20,0x6C,0x65,0x66,
-	0x00,0x17,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
+	0x74,0x6D,0x6F,0x73,0x74,0x3F,0x70,0x6F,0x73,0x69,0x74,0x69,
-	0x50,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x62,0x72,0x65,0x61,
+	0x6F,0x6E,0x20,0x61,0x6E,0x64,0x20,0x24,0x46,0x46,0x20,0x74,
-	0x6B,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,
+	0x68,0x65,0x20,0x72,0x69,0x67,0x68,0x74,0x6D,0x6F,0x73,0x74,
-	0x32,0x1C,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x44,0x20,
+	0x2E,0x20,0x4E,0x6F,0x74,0x65,0x20,0x74,0x68,0x61,0x74,0x20,
-	0x2B,0x20,0x50,0x61,0x74,0x74,0x65,0x72,0x6E,0x2D,0x70,0x6F,
+	0x73,0x6F,0x6D,0x65,0x20,0x73,0x6F,0x75,0x6E,0x64,0x20,0x63,
-	0x73,0x69,0x74,0x69,0x6F,0x6E,0x00,0x3C,0x54,0x68,0x69,0x73,
+	0x61,0x72,0x64,0x73,0x20,0x28,0x65,0x78,0x2E,0x30,0x47,0x55,
-	0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x77,0x69,0x6C,
+	0x53,0x29,0x20,0x63,0x61,0x6E,0x27,0x74,0x20,0x75,0x73,0x65,
-	0x6C,0x20,0x6A,0x75,0x6D,0x70,0x20,0x74,0x6F,0x20,0x74,0x68,
+	0x20,0x61,0x73,0x20,0x6D,0x61,0x6E,0x79,0x20,0x61,0x73,0x20,
-	0x65,0x20,0x6E,0x65,0x78,0x74,0x20,0x70,0x61,0x74,0x74,0x65,
+	0x32,0x35,0x36,0x20,0x70,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,
-	0x72,0x6E,0x20,0x61,0x6E,0x64,0x20,0x70,0x6C,0x61,0x79,0x20,
+	0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x73,0x2E,0x00,0x17,
-	0x66,0x72,0x6F,0x6D,0x20,0x74,0x68,0x65,0x13,0x73,0x70,0x65,
+	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x61,
-	0x63,0x69,0x66,0x69,0x65,0x64,0x20,0x70,0x6F,0x73,0x69,0x74,
+	0x6D,0x70,0x6C,0x65,0x20,0x6F,0x66,0x66,0x73,0x65,0x74,0x0B,
-	0x69,0x6F,0x6E,0x2E,0x00,0x22,0x40,0x58,0x30,0x34,0x30,0x40,
+	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x12,
-	0x43,0x30,0x30,0x31,0x53,0x65,0x74,0x20,0x66,0x69,0x6C,0x74,
+	0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x39,0x20,0x2B,0x20,
-	0x65,0x72,0x20,0x28,0x41,0x6D,0x69,0x67,0x61,0x20,0x6F,0x6E,
+	0x4F,0x66,0x66,0x73,0x65,0x74,0x00,0x41,0x54,0x68,0x69,0x73,
-	0x6C,0x79,0x21,0x29,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x43,0x30,0x30,0x32,0x13,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,
-	0x20,0x45,0x30,0x20,0x2B,0x20,0x53,0x74,0x61,0x74,0x75,0x73,
-	0x00,0x38,0x55,0x73,0x65,0x20,0x45,0x30,0x30,0x20,0x61,0x6E,
-	0x64,0x20,0x79,0x6F,0x75,0x72,0x20,0x74,0x75,0x6E,0x65,0x20,
-	0x77,0x69,0x6C,0x6C,0x20,0x73,0x6F,0x75,0x6E,0x64,0x20,0x72,
-	0x65,0x61,0x6C,0x6C,0x79,0x20,0x62,0x61,0x64,0x20,0x6F,0x6E,
-	0x20,0x61,0x6E,0x20,0x41,0x6D,0x69,0x67,0x61,0x21,0x00,0x21,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x46,0x69,
-	0x6E,0x65,0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,
-	0x6F,0x20,0x75,0x70,0x2F,0x64,0x6F,0x77,0x6E,0x0B,0x3E,0x40,
-	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x19,0x53,0x79,
-	0x6E,0x74,0x61,0x78,0x3A,0x20,0x45,0x28,0x31,0x20,0x6F,0x72,
-	0x20,0x32,0x29,0x20,0x2B,0x20,0x53,0x70,0x65,0x65,0x64,0x00,
-	0x3F,0x54,0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,
-	0x64,0x20,0x77,0x6F,0x72,0x6B,0x73,0x20,0x61,0x73,0x20,0x70,
-	0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x75,0x70,
-	0x2F,0x64,0x6F,0x77,0x6E,0x2C,0x20,0x62,0x75,0x74,0x20,0x69,
-	0x74,0x20,0x6F,0x6E,0x6C,0x79,0x20,0x73,0x6C,0x69,0x64,0x65,
-	0x73,0x20,0x75,0x70,0x05,0x6F,0x6E,0x63,0x65,0x2E,0x00,0x1F,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x65,
-	0x74,0x20,0x67,0x6C,0x69,0x73,0x73,0x61,0x6E,0x64,0x6F,0x20,
-	0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x0B,0x3E,0x40,0x58,0x30,
-	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x13,0x53,0x79,0x6E,0x74,
-	0x61,0x78,0x3A,0x20,0x45,0x33,0x20,0x2B,0x20,0x53,0x74,0x61,
-	0x74,0x75,0x73,0x00,0x41,0x49,0x66,0x20,0x53,0x74,0x61,0x74,
-	0x75,0x73,0x20,0x69,0x73,0x20,0x3D,0x31,0x2C,0x20,0x74,0x68,
-	0x65,0x20,0x66,0x72,0x65,0x71,0x75,0x65,0x6E,0x63,0x79,0x20,
-	0x77,0x68,0x65,0x6E,0x20,0x75,0x73,0x69,0x6E,0x67,0x20,0x74,
-	0x6F,0x6E,0x65,0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,
-	0x74,0x6F,0x20,0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x72,
-	0x6F,0x75,0x6E,0x64,0x65,0x64,0x20,0x74,0x6F,0x20,0x74,0x68,
-	0x65,0x20,0x6E,0x65,0x61,0x72,0x65,0x73,0x74,0x20,0x68,0x61,
-	0x6C,0x66,0x74,0x6F,0x6E,0x65,0x2E,0x00,0x1D,0x40,0x58,0x30,
-	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x65,0x74,0x20,0x76,
-	0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x63,0x6F,0x6E,0x74,0x72,
-	0x6F,0x6C,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
-	0x30,0x32,0x11,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x45,
-	0x34,0x20,0x2B,0x20,0x54,0x79,0x70,0x65,0x00,0x2C,0x54,0x68,
-	0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x63,
-	0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x73,0x20,0x74,0x68,0x65,0x20,
-	0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x77,0x61,0x76,0x65,
-	0x20,0x66,0x6F,0x72,0x6D,0x2E,0x00,0x33,0x54,0x79,0x70,0x65,
-	0x3A,0x20,0x30,0x20,0x3D,0x20,0x53,0x69,0x6E,0x65,0x20,0x20,
-	0x20,0x20,0x20,0x20,0x20,0x31,0x20,0x3D,0x20,0x52,0x61,0x6D,
-	0x70,0x20,0x64,0x6F,0x77,0x6E,0x20,0x20,0x20,0x20,0x20,0x20,
-	0x20,0x32,0x20,0x3D,0x20,0x53,0x71,0x75,0x61,0x72,0x65,0x00,
-	0x44,0x49,0x66,0x20,0x79,0x6F,0x75,0x20,0x61,0x64,0x64,0x20,
-	0x34,0x20,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x74,0x79,0x70,
-	0x65,0x2C,0x20,0x74,0x68,0x65,0x20,0x77,0x61,0x76,0x65,0x20,
-	0x66,0x6F,0x72,0x6D,0x20,0x77,0x69,0x6C,0x6C,0x20,0x6E,0x6F,
-	0x74,0x20,0x62,0x65,0x20,0x72,0x65,0x74,0x72,0x69,0x67,0x67,
-	0x65,0x64,0x20,0x77,0x68,0x65,0x6E,0x20,0x61,0x19,0x6E,0x65,
-	0x77,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,
-	0x20,0x69,0x73,0x20,0x70,0x6C,0x61,0x79,0x65,0x64,0x2E,0x00,
-	0x17,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,
-	0x65,0x74,0x20,0x66,0x69,0x6E,0x65,0x2D,0x74,0x75,0x6E,0x65,
-	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
-	0x11,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x45,0x35,0x20,
-	0x2B,0x20,0x54,0x75,0x6E,0x65,0x00,0x3F,0x54,0x68,0x69,0x73,
 	0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x73,0x68,0x6F,
 	0x75,0x6C,0x64,0x20,0x62,0x65,0x20,0x75,0x73,0x65,0x64,0x20,
 	0x74,0x6F,0x67,0x65,0x74,0x68,0x65,0x72,0x20,0x77,0x69,0x74,
-	0x68,0x20,0x61,0x20,0x6E,0x6F,0x74,0x65,0x2E,0x20,0x49,0x74,
+	0x68,0x20,0x61,0x20,0x6E,0x6F,0x74,0x65,0x2E,0x20,0x54,0x68,
-	0x20,0x77,0x69,0x6C,0x6C,0x20,0x63,0x61,0x75,0x73,0x65,0x44,
+	0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x77,0x69,0x6C,
-	0x61,0x6E,0x6F,0x74,0x68,0x65,0x72,0x20,0x66,0x69,0x6E,0x65,
+	0x6C,0x2D,0x62,0x65,0x20,0x70,0x6C,0x61,0x79,0x65,0x64,0x20,
-	0x2D,0x74,0x75,0x6E,0x65,0x20,0x76,0x61,0x6C,0x75,0x65,0x20,
+	0x66,0x72,0x6F,0x6D,0x20,0x28,0x4F,0x66,0x66,0x73,0x65,0x74,
-	0x74,0x6F,0x20,0x62,0x65,0x20,0x75,0x73,0x65,0x64,0x2E,0x20,
+	0x2A,0x24,0x31,0x30,0x30,0x29,0x20,0x69,0x6E,0x73,0x74,0x65,
-	0x49,0x74,0x20,0x73,0x65,0x65,0x6D,0x73,0x20,0x71,0x75,0x69,
+	0x61,0x64,0x20,0x6F,0x66,0x20,0x7A,0x65,0x72,0x6F,0x2E,0x00,
-	0x74,0x65,0x20,0x75,0x6E,0x75,0x73,0x61,0x62,0x6C,0x65,0x20,
+	0x16,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x56,
-	0x74,0x6F,0x20,0x6D,0x65,0x2E,0x2E,0x2E,0x00,0x16,0x40,0x58,
+	0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x0B,
-	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x50,0x61,0x74,0x74,
+	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x21,
-	0x65,0x72,0x6E,0x20,0x6C,0x6F,0x6F,0x70,0x0B,0x3E,0x40,0x58,
+	0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x41,0x20,0x2B,0x20,
-	0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x12,0x53,0x79,0x6E,
+	0x55,0x70,0x20,0x73,0x70,0x65,0x65,0x64,0x20,0x2B,0x20,0x44,
-	0x74,0x61,0x78,0x3A,0x20,0x45,0x36,0x20,0x2B,0x20,0x43,0x6F,
+	0x6F,0x77,0x6E,0x20,0x73,0x70,0x65,0x65,0x64,0x00,0x3D,0x53,
-	0x75,0x6E,0x74,0x00,0x45,0x49,0x66,0x20,0x63,0x6F,0x75,0x6E,
+	0x6C,0x69,0x64,0x65,0x73,0x20,0x74,0x68,0x65,0x20,0x63,0x75,
-	0x74,0x20,0x69,0x73,0x20,0x7A,0x65,0x72,0x6F,0x2C,0x20,0x74,
+	0x72,0x72,0x65,0x6E,0x74,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,
-	0x68,0x65,0x20,0x62,0x65,0x67,0x69,0x6E,0x6E,0x69,0x6E,0x67,
+	0x20,0x75,0x70,0x20,0x6F,0x72,0x20,0x64,0x6F,0x77,0x6E,0x2E,
-	0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x6C,0x6F,0x6F,0x70,
+	0x20,0x45,0x69,0x74,0x68,0x65,0x72,0x20,0x75,0x70,0x20,0x73,
-	0x20,0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x73,0x70,0x65,
+	0x70,0x65,0x65,0x64,0x20,0x6F,0x72,0x20,0x64,0x6F,0x77,0x6E,
-	0x63,0x69,0x66,0x69,0x65,0x64,0x2E,0x20,0x57,0x68,0x65,0x6E,
+	0x15,0x73,0x70,0x65,0x65,0x64,0x20,0x73,0x68,0x6F,0x75,0x6C,
-	0x20,0x61,0x40,0x6E,0x6F,0x6E,0x2D,0x7A,0x65,0x72,0x6F,0x20,
+	0x64,0x20,0x62,0x65,0x20,0x7A,0x65,0x72,0x6F,0x2E,0x00,0x17,
-	0x76,0x61,0x6C,0x75,0x65,0x20,0x69,0x73,0x20,0x75,0x73,0x65,
+	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x50,0x6F,
-	0x64,0x2C,0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x74,0x74,0x65,
+	0x73,0x69,0x74,0x69,0x6F,0x6E,0x20,0x6A,0x75,0x6D,0x70,0x0B,
-	0x72,0x6E,0x20,0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x6C,
+	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x14,
-	0x6F,0x6F,0x70,0x65,0x64,0x20,0x66,0x72,0x6F,0x6D,0x20,0x74,
+	0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x42,0x20,0x2B,0x20,
-	0x68,0x65,0x20,0x6C,0x6F,0x6F,0x70,0x06,0x73,0x74,0x61,0x72,
+	0x50,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x00,0x41,0x54,0x68,
-	0x74,0x2E,0x00,0x1D,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
+	0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x77,
-	0x30,0x31,0x53,0x65,0x74,0x20,0x74,0x72,0x65,0x6D,0x6F,0x6C,
+	0x69,0x6C,0x6C,0x20,0x6A,0x75,0x6D,0x70,0x20,0x74,0x6F,0x20,
-	0x6F,0x20,0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x0B,0x3E,0x40,
-	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x11,0x53,0x79,
-	0x6E,0x74,0x61,0x78,0x3A,0x20,0x45,0x37,0x20,0x2B,0x20,0x54,
-	0x79,0x70,0x65,0x00,0x3A,0x54,0x68,0x69,0x73,0x20,0x63,0x6F,
-	0x6D,0x6D,0x61,0x6E,0x64,0x20,0x77,0x6F,0x72,0x6B,0x73,0x20,
-	0x65,0x78,0x61,0x63,0x74,0x6C,0x79,0x20,0x61,0x73,0x20,0x73,
-	0x65,0x74,0x20,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x63,
-	0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x2C,0x20,0x62,0x75,0x74,0x20,
-	0x74,0x68,0x65,0x2A,0x74,0x72,0x65,0x6D,0x6F,0x6C,0x6F,0x20,
-	0x77,0x61,0x76,0x65,0x20,0x66,0x6F,0x72,0x6D,0x20,0x77,0x69,
-	0x6C,0x6C,0x20,0x62,0x65,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,
-	0x64,0x20,0x69,0x6E,0x73,0x74,0x65,0x61,0x64,0x2E,0x00,0x15,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x52,0x65,
-	0x74,0x72,0x69,0x67,0x20,0x6E,0x6F,0x74,0x65,0x0B,0x3E,0x40,
-	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x15,0x53,0x79,
-	0x6E,0x74,0x61,0x78,0x3A,0x20,0x45,0x39,0x20,0x2B,0x20,0x49,
-	0x6E,0x74,0x65,0x72,0x76,0x61,0x6C,0x00,0x2D,0x52,0x65,0x74,
-	0x72,0x69,0x67,0x73,0x20,0x74,0x68,0x65,0x20,0x6E,0x6F,0x74,
-	0x65,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65,0x20,0x73,
-	0x70,0x65,0x63,0x69,0x66,0x69,0x65,0x64,0x20,0x69,0x6E,0x74,
-	0x65,0x72,0x76,0x61,0x6C,0x2E,0x00,0x23,0x40,0x58,0x30,0x34,
-	0x30,0x40,0x43,0x30,0x30,0x31,0x46,0x69,0x6E,0x65,0x20,0x76,
-	0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x20,
-	0x75,0x70,0x2F,0x64,0x6F,0x77,0x6E,0x0B,0x3E,0x40,0x58,0x30,
-	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x19,0x53,0x79,0x6E,0x74,
-	0x61,0x78,0x3A,0x20,0x45,0x28,0x41,0x20,0x6F,0x72,0x20,0x42,
-	0x29,0x20,0x2B,0x20,0x53,0x70,0x65,0x65,0x64,0x00,0x44,0x54,
-	0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,
-	0x77,0x6F,0x72,0x6B,0x73,0x20,0x61,0x73,0x20,0x74,0x68,0x65,
-	0x20,0x75,0x73,0x75,0x61,0x6C,0x20,0x76,0x6F,0x6C,0x75,0x6D,
-	0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x2C,0x20,0x62,0x75,0x74,
-	0x20,0x69,0x74,0x20,0x77,0x69,0x6C,0x6C,0x20,0x6F,0x6E,0x6C,
-	0x79,0x20,0x73,0x6C,0x69,0x64,0x65,0x05,0x6F,0x6E,0x63,0x65,
-	0x2E,0x00,0x12,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
-	0x31,0x4E,0x6F,0x74,0x65,0x20,0x63,0x75,0x74,0x0B,0x3E,0x40,
-	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x11,0x53,0x79,
-	0x6E,0x74,0x61,0x78,0x3A,0x20,0x45,0x43,0x20,0x2B,0x20,0x54,
-	0x69,0x63,0x6B,0x00,0x43,0x43,0x75,0x74,0x73,0x20,0x74,0x68,
-	0x65,0x20,0x6E,0x6F,0x74,0x65,0x20,0x61,0x74,0x20,0x74,0x68,
-	0x65,0x20,0x73,0x70,0x65,0x63,0x69,0x66,0x69,0x65,0x64,0x20,
-	0x74,0x69,0x63,0x6B,0x2E,0x20,0x4E,0x6F,0x74,0x65,0x20,0x74,
-	0x68,0x61,0x74,0x20,0x69,0x74,0x20,0x77,0x69,0x6C,0x6C,0x20,
-	0x6F,0x6E,0x6C,0x79,0x20,0x73,0x65,0x74,0x20,0x74,0x68,0x65,
-	0x34,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x74,0x6F,0x20,0x7A,
-	0x65,0x72,0x6F,0x2C,0x20,0x61,0x6E,0x64,0x20,0x74,0x68,0x65,
-	0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x77,0x69,0x6C,0x6C,
-	0x20,0x73,0x74,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x70,0x6C,
-	0x61,0x79,0x65,0x64,0x2E,0x00,0x14,0x40,0x58,0x30,0x34,0x30,
-	0x40,0x43,0x30,0x30,0x31,0x4E,0x6F,0x74,0x65,0x20,0x64,0x65,
-	0x6C,0x61,0x79,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
-	0x30,0x30,0x32,0x12,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,
-	0x45,0x44,0x20,0x2B,0x20,0x54,0x69,0x63,0x6B,0x73,0x00,0x3E,
-	0x54,0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,
-	0x20,0x77,0x69,0x6C,0x6C,0x20,0x64,0x65,0x6C,0x61,0x79,0x20,
-	0x74,0x68,0x65,0x20,0x6E,0x6F,0x74,0x65,0x20,0x74,0x68,0x65,
-	0x20,0x73,0x65,0x6C,0x65,0x63,0x74,0x65,0x64,0x20,0x6E,0x75,
-	0x6D,0x62,0x65,0x72,0x20,0x6F,0x66,0x20,0x74,0x69,0x63,0x6B,
-	0x73,0x2E,0x00,0x17,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
-	0x30,0x31,0x50,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x64,0x65,
-	0x6C,0x61,0x79,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
-	0x30,0x30,0x32,0x12,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,
-	0x45,0x45,0x20,0x2B,0x20,0x4E,0x6F,0x74,0x65,0x73,0x00,0x41,
-	0x54,0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,
-	0x20,0x77,0x69,0x6C,0x6C,0x20,0x64,0x65,0x6C,0x61,0x79,0x20,
-	0x74,0x68,0x65,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,
 	0x74,0x68,0x65,0x20,0x73,0x65,0x6C,0x65,0x63,0x74,0x65,0x64,
-	0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x20,0x6F,0x66,0x20,0x6E,
+	0x20,0x73,0x6F,0x6E,0x67,0x20,0x70,0x6F,0x73,0x69,0x74,0x69,
-	0x6F,0x74,0x65,0x73,0x2E,0x00,0x13,0x40,0x58,0x30,0x34,0x30,
+	0x6F,0x6E,0x20,0x61,0x6E,0x64,0x20,0x70,0x6C,0x61,0x79,0x20,
-	0x40,0x43,0x30,0x30,0x31,0x53,0x65,0x74,0x20,0x73,0x70,0x65,
+	0x74,0x68,0x65,0x1B,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,
-	0x65,0x64,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
+	0x66,0x72,0x6F,0x6D,0x20,0x74,0x68,0x65,0x20,0x62,0x65,0x67,
-	0x30,0x32,0x11,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x46,
+	0x69,0x6E,0x6E,0x69,0x6E,0x67,0x2E,0x00,0x14,0x40,0x58,0x30,
-	0x20,0x2B,0x20,0x56,0x61,0x6C,0x75,0x65,0x00,0x42,0x54,0x68,
+	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x65,0x74,0x20,0x76,
+	0x6F,0x6C,0x75,0x6D,0x65,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,
+	0x40,0x43,0x30,0x30,0x32,0x12,0x53,0x79,0x6E,0x74,0x61,0x78,
+	0x3A,0x20,0x43,0x20,0x2B,0x20,0x56,0x6F,0x6C,0x75,0x6D,0x65,
+	0x00,0x3E,0x53,0x65,0x74,0x73,0x20,0x74,0x68,0x65,0x20,0x63,
+	0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x76,0x6F,0x6C,0x75,0x6D,
+	0x65,0x2E,0x20,0x54,0x68,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,
+	0x65,0x20,0x73,0x68,0x6F,0x75,0x6C,0x64,0x20,0x6E,0x6F,0x74,
+	0x20,0x62,0x65,0x20,0x67,0x72,0x65,0x61,0x74,0x65,0x72,0x20,
+	0x74,0x68,0x61,0x6E,0x04,0x24,0x34,0x30,0x2E,0x00,0x17,0x40,
+	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x50,0x61,0x74,
+	0x74,0x65,0x72,0x6E,0x20,0x62,0x72,0x65,0x61,0x6B,0x0B,0x3E,
+	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x1C,0x53,
+	0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x44,0x20,0x2B,0x20,0x50,
+	0x61,0x74,0x74,0x65,0x72,0x6E,0x2D,0x70,0x6F,0x73,0x69,0x74,
+	0x69,0x6F,0x6E,0x00,0x3C,0x54,0x68,0x69,0x73,0x20,0x63,0x6F,
+	0x6D,0x6D,0x61,0x6E,0x64,0x20,0x77,0x69,0x6C,0x6C,0x20,0x6A,
+	0x75,0x6D,0x70,0x20,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x6E,
+	0x65,0x78,0x74,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,
+	0x61,0x6E,0x64,0x20,0x70,0x6C,0x61,0x79,0x20,0x66,0x72,0x6F,
+	0x6D,0x20,0x74,0x68,0x65,0x13,0x73,0x70,0x65,0x63,0x69,0x66,
+	0x69,0x65,0x64,0x20,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,
+	0x2E,0x00,0x22,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
+	0x31,0x53,0x65,0x74,0x20,0x66,0x69,0x6C,0x74,0x65,0x72,0x20,
+	0x28,0x41,0x6D,0x69,0x67,0x61,0x20,0x6F,0x6E,0x6C,0x79,0x21,
+	0x29,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,
+	0x32,0x13,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x45,0x30,
+	0x20,0x2B,0x20,0x53,0x74,0x61,0x74,0x75,0x73,0x00,0x38,0x55,
+	0x73,0x65,0x20,0x45,0x30,0x30,0x20,0x61,0x6E,0x64,0x20,0x79,
+	0x6F,0x75,0x72,0x20,0x74,0x75,0x6E,0x65,0x20,0x77,0x69,0x6C,
+	0x6C,0x20,0x73,0x6F,0x75,0x6E,0x64,0x20,0x72,0x65,0x61,0x6C,
+	0x6C,0x79,0x20,0x62,0x61,0x64,0x20,0x6F,0x6E,0x20,0x61,0x6E,
+	0x20,0x41,0x6D,0x69,0x67,0x61,0x21,0x00,0x21,0x40,0x58,0x30,
+	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x46,0x69,0x6E,0x65,0x20,
+	0x70,0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x75,
+	0x70,0x2F,0x64,0x6F,0x77,0x6E,0x0B,0x3E,0x40,0x58,0x30,0x36,
+	0x30,0x40,0x43,0x30,0x30,0x32,0x19,0x53,0x79,0x6E,0x74,0x61,
+	0x78,0x3A,0x20,0x45,0x28,0x31,0x20,0x6F,0x72,0x20,0x32,0x29,
+	0x20,0x2B,0x20,0x53,0x70,0x65,0x65,0x64,0x00,0x3F,0x54,0x68,
 	0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x77,
-	0x69,0x6C,0x6C,0x20,0x73,0x65,0x74,0x20,0x74,0x68,0x65,0x20,
+	0x6F,0x72,0x6B,0x73,0x20,0x61,0x73,0x20,0x70,0x6F,0x72,0x74,
-	0x73,0x70,0x65,0x65,0x64,0x20,0x6F,0x72,0x20,0x42,0x50,0x4D,
+	0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x75,0x70,0x2F,0x64,0x6F,
-	0x20,0x76,0x61,0x6C,0x75,0x65,0x20,0x6F,0x66,0x20,0x74,0x68,
+	0x77,0x6E,0x2C,0x20,0x62,0x75,0x74,0x20,0x69,0x74,0x20,0x6F,
-	0x65,0x20,0x73,0x6F,0x6E,0x67,0x2E,0x20,0x49,0x66,0x20,0x76,
+	0x6E,0x6C,0x79,0x20,0x73,0x6C,0x69,0x64,0x65,0x73,0x20,0x75,
-	0x61,0x6C,0x75,0x65,0x3F,0x69,0x73,0x20,0x6C,0x65,0x73,0x73,
+	0x70,0x05,0x6F,0x6E,0x63,0x65,0x2E,0x00,0x1F,0x40,0x58,0x30,
-	0x20,0x74,0x68,0x61,0x6E,0x20,0x24,0x32,0x30,0x2C,0x20,0x74,
-	0x68,0x65,0x20,0x73,0x70,0x65,0x65,0x64,0x20,0x77,0x69,0x6C,
-	0x6C,0x20,0x62,0x65,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x64,
-	0x2E,0x20,0x4F,0x74,0x68,0x65,0x72,0x77,0x69,0x73,0x65,0x2C,
-	0x20,0x74,0x68,0x65,0x20,0x42,0x50,0x4D,0x16,0x76,0x61,0x6C,
-	0x75,0x65,0x20,0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x63,
-	0x68,0x61,0x6E,0x67,0x65,0x64,0x2E,0x00,0x1B,0x40,0x58,0x30,
 	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x65,0x74,0x20,0x67,
-	0x6C,0x6F,0x62,0x61,0x6C,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,
+	0x6C,0x69,0x73,0x73,0x61,0x6E,0x64,0x6F,0x20,0x63,0x6F,0x6E,
-	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
+	0x74,0x72,0x6F,0x6C,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x12,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x47,0x20,0x2B,
+	0x43,0x30,0x30,0x32,0x13,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,
-	0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x00,0x42,0x53,0x65,0x74,
+	0x20,0x45,0x33,0x20,0x2B,0x20,0x53,0x74,0x61,0x74,0x75,0x73,
-	0x73,0x20,0x74,0x68,0x65,0x20,0x67,0x6C,0x6F,0x62,0x61,0x6C,
+	0x00,0x41,0x49,0x66,0x20,0x53,0x74,0x61,0x74,0x75,0x73,0x20,
-	0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x2E,0x20,0x54,0x68,0x65,
+	0x69,0x73,0x20,0x3D,0x31,0x2C,0x20,0x74,0x68,0x65,0x20,0x66,
-	0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x68,0x6F,0x75,
+	0x72,0x65,0x71,0x75,0x65,0x6E,0x63,0x79,0x20,0x77,0x68,0x65,
-	0x6C,0x64,0x20,0x6E,0x6F,0x74,0x20,0x62,0x65,0x20,0x67,0x72,
+	0x6E,0x20,0x75,0x73,0x69,0x6E,0x67,0x20,0x74,0x6F,0x6E,0x65,
-	0x65,0x61,0x74,0x65,0x72,0x20,0x74,0x68,0x61,0x6E,0x20,0x24,
+	0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,
-	0x34,0x30,0x2E,0x00,0x1D,0x40,0x58,0x30,0x34,0x30,0x40,0x43,
+	0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x72,0x6F,0x75,0x6E,
-	0x30,0x30,0x31,0x47,0x6C,0x6F,0x62,0x61,0x6C,0x20,0x76,0x6F,
+	0x64,0x65,0x64,0x20,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x6E,
-	0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x0B,0x3E,
+	0x65,0x61,0x72,0x65,0x73,0x74,0x20,0x68,0x61,0x6C,0x66,0x74,
-	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x21,0x53,
+	0x6F,0x6E,0x65,0x2E,0x00,0x1D,0x40,0x58,0x30,0x34,0x30,0x40,
-	0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x48,0x20,0x2B,0x20,0x55,
+	0x43,0x30,0x30,0x31,0x53,0x65,0x74,0x20,0x76,0x69,0x62,0x72,
-	0x70,0x20,0x73,0x70,0x65,0x65,0x64,0x20,0x2B,0x20,0x44,0x6F,
+	0x61,0x74,0x6F,0x20,0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x0B,
-	0x77,0x6E,0x20,0x73,0x70,0x65,0x65,0x64,0x00,0x3D,0x54,0x68,
+	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x11,
-	0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x77,
+	0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x45,0x34,0x20,0x2B,
-	0x6F,0x72,0x6B,0x73,0x20,0x65,0x78,0x61,0x63,0x74,0x6C,0x79,
+	0x20,0x54,0x79,0x70,0x65,0x00,0x2C,0x54,0x68,0x69,0x73,0x20,
-	0x20,0x61,0x73,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,
+	0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x63,0x6F,0x6E,0x74,
+	0x72,0x6F,0x6C,0x73,0x20,0x74,0x68,0x65,0x20,0x76,0x69,0x62,
+	0x72,0x61,0x74,0x6F,0x20,0x77,0x61,0x76,0x65,0x20,0x66,0x6F,
+	0x72,0x6D,0x2E,0x00,0x33,0x54,0x79,0x70,0x65,0x3A,0x20,0x30,
+	0x20,0x3D,0x20,0x53,0x69,0x6E,0x65,0x20,0x20,0x20,0x20,0x20,
+	0x20,0x20,0x31,0x20,0x3D,0x20,0x52,0x61,0x6D,0x70,0x20,0x64,
+	0x6F,0x77,0x6E,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x32,0x20,
+	0x3D,0x20,0x53,0x71,0x75,0x61,0x72,0x65,0x00,0x44,0x49,0x66,
+	0x20,0x79,0x6F,0x75,0x20,0x61,0x64,0x64,0x20,0x34,0x20,0x74,
+	0x6F,0x20,0x74,0x68,0x65,0x20,0x74,0x79,0x70,0x65,0x2C,0x20,
+	0x74,0x68,0x65,0x20,0x77,0x61,0x76,0x65,0x20,0x66,0x6F,0x72,
+	0x6D,0x20,0x77,0x69,0x6C,0x6C,0x20,0x6E,0x6F,0x74,0x20,0x62,
+	0x65,0x20,0x72,0x65,0x74,0x72,0x69,0x67,0x67,0x65,0x64,0x20,
+	0x77,0x68,0x65,0x6E,0x20,0x61,0x19,0x6E,0x65,0x77,0x20,0x69,
+	0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x69,0x73,
+	0x20,0x70,0x6C,0x61,0x79,0x65,0x64,0x2E,0x00,0x17,0x40,0x58,
+	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x65,0x74,0x20,
+	0x66,0x69,0x6E,0x65,0x2D,0x74,0x75,0x6E,0x65,0x0B,0x3E,0x40,
+	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x11,0x53,0x79,
+	0x6E,0x74,0x61,0x78,0x3A,0x20,0x45,0x35,0x20,0x2B,0x20,0x54,
+	0x75,0x6E,0x65,0x00,0x3F,0x54,0x68,0x69,0x73,0x20,0x63,0x6F,
+	0x6D,0x6D,0x61,0x6E,0x64,0x20,0x73,0x68,0x6F,0x75,0x6C,0x64,
+	0x20,0x62,0x65,0x20,0x75,0x73,0x65,0x64,0x20,0x74,0x6F,0x67,
+	0x65,0x74,0x68,0x65,0x72,0x20,0x77,0x69,0x74,0x68,0x20,0x61,
+	0x20,0x6E,0x6F,0x74,0x65,0x2E,0x20,0x49,0x74,0x20,0x77,0x69,
+	0x6C,0x6C,0x20,0x63,0x61,0x75,0x73,0x65,0x44,0x61,0x6E,0x6F,
+	0x74,0x68,0x65,0x72,0x20,0x66,0x69,0x6E,0x65,0x2D,0x74,0x75,
+	0x6E,0x65,0x20,0x76,0x61,0x6C,0x75,0x65,0x20,0x74,0x6F,0x20,
+	0x62,0x65,0x20,0x75,0x73,0x65,0x64,0x2E,0x20,0x49,0x74,0x20,
+	0x73,0x65,0x65,0x6D,0x73,0x20,0x71,0x75,0x69,0x74,0x65,0x20,
+	0x75,0x6E,0x75,0x73,0x61,0x62,0x6C,0x65,0x20,0x74,0x6F,0x20,
+	0x6D,0x65,0x2E,0x2E,0x2E,0x00,0x16,0x40,0x58,0x30,0x34,0x30,
+	0x40,0x43,0x30,0x30,0x31,0x50,0x61,0x74,0x74,0x65,0x72,0x6E,
+	0x20,0x6C,0x6F,0x6F,0x70,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,
+	0x40,0x43,0x30,0x30,0x32,0x12,0x53,0x79,0x6E,0x74,0x61,0x78,
+	0x3A,0x20,0x45,0x36,0x20,0x2B,0x20,0x43,0x6F,0x75,0x6E,0x74,
+	0x00,0x45,0x49,0x66,0x20,0x63,0x6F,0x75,0x6E,0x74,0x20,0x69,
+	0x73,0x20,0x7A,0x65,0x72,0x6F,0x2C,0x20,0x74,0x68,0x65,0x20,
+	0x62,0x65,0x67,0x69,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x6F,0x66,
+	0x20,0x74,0x68,0x65,0x20,0x6C,0x6F,0x6F,0x70,0x20,0x77,0x69,
+	0x6C,0x6C,0x20,0x62,0x65,0x20,0x73,0x70,0x65,0x63,0x69,0x66,
+	0x69,0x65,0x64,0x2E,0x20,0x57,0x68,0x65,0x6E,0x20,0x61,0x40,
+	0x6E,0x6F,0x6E,0x2D,0x7A,0x65,0x72,0x6F,0x20,0x76,0x61,0x6C,
+	0x75,0x65,0x20,0x69,0x73,0x20,0x75,0x73,0x65,0x64,0x2C,0x20,
+	0x74,0x68,0x65,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,
+	0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x6C,0x6F,0x6F,0x70,
+	0x65,0x64,0x20,0x66,0x72,0x6F,0x6D,0x20,0x74,0x68,0x65,0x20,
+	0x6C,0x6F,0x6F,0x70,0x06,0x73,0x74,0x61,0x72,0x74,0x2E,0x00,
+	0x1D,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,
+	0x65,0x74,0x20,0x74,0x72,0x65,0x6D,0x6F,0x6C,0x6F,0x20,0x63,
+	0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x0B,0x3E,0x40,0x58,0x30,0x36,
+	0x30,0x40,0x43,0x30,0x30,0x32,0x11,0x53,0x79,0x6E,0x74,0x61,
+	0x78,0x3A,0x20,0x45,0x37,0x20,0x2B,0x20,0x54,0x79,0x70,0x65,
+	0x00,0x3A,0x54,0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,
+	0x6E,0x64,0x20,0x77,0x6F,0x72,0x6B,0x73,0x20,0x65,0x78,0x61,
+	0x63,0x74,0x6C,0x79,0x20,0x61,0x73,0x20,0x73,0x65,0x74,0x20,
+	0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x63,0x6F,0x6E,0x74,
+	0x72,0x6F,0x6C,0x2C,0x20,0x62,0x75,0x74,0x20,0x74,0x68,0x65,
+	0x2A,0x74,0x72,0x65,0x6D,0x6F,0x6C,0x6F,0x20,0x77,0x61,0x76,
+	0x65,0x20,0x66,0x6F,0x72,0x6D,0x20,0x77,0x69,0x6C,0x6C,0x20,
+	0x62,0x65,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x64,0x20,0x69,
+	0x6E,0x73,0x74,0x65,0x61,0x64,0x2E,0x00,0x15,0x40,0x58,0x30,
+	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x52,0x65,0x74,0x72,0x69,
+	0x67,0x20,0x6E,0x6F,0x74,0x65,0x0B,0x3E,0x40,0x58,0x30,0x36,
+	0x30,0x40,0x43,0x30,0x30,0x32,0x15,0x53,0x79,0x6E,0x74,0x61,
+	0x78,0x3A,0x20,0x45,0x39,0x20,0x2B,0x20,0x49,0x6E,0x74,0x65,
+	0x72,0x76,0x61,0x6C,0x00,0x2D,0x52,0x65,0x74,0x72,0x69,0x67,
+	0x73,0x20,0x74,0x68,0x65,0x20,0x6E,0x6F,0x74,0x65,0x20,0x77,
+	0x69,0x74,0x68,0x20,0x74,0x68,0x65,0x20,0x73,0x70,0x65,0x63,
+	0x69,0x66,0x69,0x65,0x64,0x20,0x69,0x6E,0x74,0x65,0x72,0x76,
+	0x61,0x6C,0x2E,0x00,0x23,0x40,0x58,0x30,0x34,0x30,0x40,0x43,
+	0x30,0x30,0x31,0x46,0x69,0x6E,0x65,0x20,0x76,0x6F,0x6C,0x75,
+	0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x20,0x75,0x70,0x2F,
+	0x64,0x6F,0x77,0x6E,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
+	0x43,0x30,0x30,0x32,0x19,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,
+	0x20,0x45,0x28,0x41,0x20,0x6F,0x72,0x20,0x42,0x29,0x20,0x2B,
+	0x20,0x53,0x70,0x65,0x65,0x64,0x00,0x44,0x54,0x68,0x69,0x73,
+	0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x77,0x6F,0x72,
+	0x6B,0x73,0x20,0x61,0x73,0x20,0x74,0x68,0x65,0x20,0x75,0x73,
+	0x75,0x61,0x6C,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,
 	0x6C,0x69,0x64,0x65,0x2C,0x20,0x62,0x75,0x74,0x20,0x69,0x74,
-	0x20,0x73,0x6C,0x69,0x64,0x65,0x73,0x20,0x74,0x68,0x65,0x16,
+	0x20,0x77,0x69,0x6C,0x6C,0x20,0x6F,0x6E,0x6C,0x79,0x20,0x73,
-	0x67,0x6C,0x6F,0x62,0x61,0x6C,0x20,0x76,0x6F,0x6C,0x75,0x6D,
+	0x6C,0x69,0x64,0x65,0x05,0x6F,0x6E,0x63,0x65,0x2E,0x00,0x12,
-	0x65,0x20,0x69,0x6E,0x73,0x74,0x65,0x61,0x64,0x2E,0x00,0x11,
+	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x4E,0x6F,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x4B,0x65,
+	0x74,0x65,0x20,0x63,0x75,0x74,0x0B,0x3E,0x40,0x58,0x30,0x36,
-	0x79,0x20,0x6F,0x66,0x66,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,
+	0x30,0x40,0x43,0x30,0x30,0x32,0x11,0x53,0x79,0x6E,0x74,0x61,
-	0x40,0x43,0x30,0x30,0x32,0x10,0x53,0x79,0x6E,0x74,0x61,0x78,
+	0x78,0x3A,0x20,0x45,0x43,0x20,0x2B,0x20,0x54,0x69,0x63,0x6B,
-	0x3A,0x20,0x4B,0x20,0x2B,0x20,0x54,0x69,0x63,0x6B,0x00,0x3C,
+	0x00,0x43,0x43,0x75,0x74,0x73,0x20,0x74,0x68,0x65,0x20,0x6E,
-	0x54,0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,
+	0x6F,0x74,0x65,0x20,0x61,0x74,0x20,0x74,0x68,0x65,0x20,0x73,
-	0x20,0x77,0x69,0x6C,0x6C,0x20,0x74,0x72,0x69,0x67,0x67,0x65,
+	0x70,0x65,0x63,0x69,0x66,0x69,0x65,0x64,0x20,0x74,0x69,0x63,
-	0x72,0x20,0x61,0x20,0x22,0x4B,0x65,0x79,0x20,0x6F,0x66,0x66,
+	0x6B,0x2E,0x20,0x4E,0x6F,0x74,0x65,0x20,0x74,0x68,0x61,0x74,
-	0x22,0x20,0x61,0x74,0x20,0x74,0x68,0x65,0x20,0x73,0x70,0x65,
+	0x20,0x69,0x74,0x20,0x77,0x69,0x6C,0x6C,0x20,0x6F,0x6E,0x6C,
-	0x63,0x69,0x66,0x69,0x65,0x64,0x20,0x74,0x69,0x63,0x6B,0x2E,
+	0x79,0x20,0x73,0x65,0x74,0x20,0x74,0x68,0x65,0x34,0x76,0x6F,
-	0x00,0x1F,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
+	0x6C,0x75,0x6D,0x65,0x20,0x74,0x6F,0x20,0x7A,0x65,0x72,0x6F,
-	0x53,0x65,0x74,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,
+	0x2C,0x20,0x61,0x6E,0x64,0x20,0x74,0x68,0x65,0x20,0x73,0x61,
-	0x20,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x0B,0x3E,0x40,
+	0x6D,0x70,0x6C,0x65,0x20,0x77,0x69,0x6C,0x6C,0x20,0x73,0x74,
-	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x14,0x53,0x79,
+	0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x70,0x6C,0x61,0x79,0x65,
-	0x6E,0x74,0x61,0x78,0x3A,0x20,0x4C,0x20,0x2B,0x20,0x50,0x6F,
+	0x64,0x2E,0x00,0x14,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
-	0x73,0x69,0x74,0x69,0x6F,0x6E,0x00,0x3E,0x43,0x68,0x61,0x6E,
+	0x30,0x31,0x4E,0x6F,0x74,0x65,0x20,0x64,0x65,0x6C,0x61,0x79,
-	0x67,0x65,0x73,0x20,0x74,0x68,0x65,0x20,0x65,0x6E,0x76,0x65,
+	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
-	0x6C,0x6F,0x70,0x65,0x20,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,
+	0x12,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x45,0x44,0x20,
-	0x6E,0x2E,0x20,0x4D,0x61,0x67,0x6E,0x75,0x73,0x20,0x74,0x6F,
+	0x2B,0x20,0x54,0x69,0x63,0x6B,0x73,0x00,0x3E,0x54,0x68,0x69,
-	0x6C,0x64,0x20,0x6D,0x65,0x20,0x74,0x68,0x61,0x74,0x20,0x69,
+	0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x77,0x69,
-	0x74,0x20,0x77,0x6F,0x75,0x6C,0x64,0x20,0x62,0x65,0x0C,0x76,
+	0x6C,0x6C,0x20,0x64,0x65,0x6C,0x61,0x79,0x20,0x74,0x68,0x65,
-	0x65,0x72,0x79,0x20,0x75,0x73,0x61,0x62,0x6C,0x65,0x2E,0x00,
+	0x20,0x6E,0x6F,0x74,0x65,0x20,0x74,0x68,0x65,0x20,0x73,0x65,
+	0x6C,0x65,0x63,0x74,0x65,0x64,0x20,0x6E,0x75,0x6D,0x62,0x65,
+	0x72,0x20,0x6F,0x66,0x20,0x74,0x69,0x63,0x6B,0x73,0x2E,0x00,
 	0x17,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x50,
-	0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x73,0x6C,0x69,0x64,0x65,
+	0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x64,0x65,0x6C,0x61,0x79,
 	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
-	0x24,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x50,0x20,0x2B,
+	0x12,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x45,0x45,0x20,
-	0x20,0x52,0x69,0x67,0x68,0x74,0x20,0x73,0x70,0x65,0x65,0x64,
+	0x2B,0x20,0x4E,0x6F,0x74,0x65,0x73,0x00,0x41,0x54,0x68,0x69,
-	0x20,0x2B,0x20,0x4C,0x65,0x66,0x74,0x20,0x73,0x70,0x65,0x65,
+	0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x77,0x69,
-	0x64,0x00,0x42,0x54,0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,
+	0x6C,0x6C,0x20,0x64,0x65,0x6C,0x61,0x79,0x20,0x74,0x68,0x65,
-	0x61,0x6E,0x64,0x20,0x73,0x6C,0x69,0x64,0x65,0x73,0x20,0x74,
+	0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x74,0x68,0x65,
-	0x68,0x65,0x20,0x70,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x70,
+	0x20,0x73,0x65,0x6C,0x65,0x63,0x74,0x65,0x64,0x20,0x6E,0x75,
-	0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x2E,0x20,0x49,0x74,0x20,
+	0x6D,0x62,0x65,0x72,0x20,0x6F,0x66,0x20,0x6E,0x6F,0x74,0x65,
-	0x77,0x6F,0x72,0x6B,0x73,0x20,0x6C,0x69,0x6B,0x65,0x20,0x74,
+	0x73,0x2E,0x00,0x13,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
-	0x68,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x3C,0x73,0x6C,
+	0x30,0x31,0x53,0x65,0x74,0x20,0x73,0x70,0x65,0x65,0x64,0x0B,
-	0x69,0x64,0x65,0x2E,0x20,0x4E,0x6F,0x74,0x65,0x20,0x74,0x68,
+	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x11,
-	0x61,0x74,0x20,0x73,0x6F,0x6D,0x65,0x20,0x73,0x6F,0x75,0x6E,
+	0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x46,0x20,0x2B,0x20,
-	0x64,0x20,0x63,0x61,0x72,0x64,0x73,0x20,0x6D,0x61,0x79,0x20,
+	0x56,0x61,0x6C,0x75,0x65,0x00,0x42,0x54,0x68,0x69,0x73,0x20,
-	0x6E,0x6F,0x74,0x20,0x68,0x61,0x6E,0x64,0x6C,0x65,0x20,0x32,
-	0x35,0x36,0x20,0x70,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x0A,0x70,
-	0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x73,0x2E,0x00,0x16,0x40,
-	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x4D,0x75,0x6C,
-	0x74,0x69,0x20,0x72,0x65,0x74,0x72,0x69,0x67,0x0B,0x3E,0x40,
-	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x24,0x53,0x79,
-	0x6E,0x74,0x61,0x78,0x3A,0x20,0x52,0x20,0x2B,0x20,0x56,0x6F,
-	0x6C,0x75,0x6D,0x65,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x20,
-	0x2B,0x20,0x49,0x6E,0x74,0x65,0x72,0x76,0x61,0x6C,0x00,0x32,
-	0x54,0x68,0x69,0x73,0x20,0x69,0x73,0x20,0x61,0x6E,0x20,0x65,
-	0x78,0x74,0x65,0x6E,0x64,0x65,0x64,0x20,0x76,0x65,0x72,0x73,
-	0x69,0x6F,0x6E,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x72,
-	0x65,0x74,0x72,0x69,0x67,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,
-	0x64,0x2E,0x00,0x0E,0x56,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x63,
-	0x68,0x61,0x6E,0x67,0x65,0x3A,0x1F,0x3E,0x40,0x58,0x31,0x30,
-	0x30,0x30,0x20,0x3D,0x20,0x4E,0x6F,0x6E,0x65,0x20,0x20,0x40,
-	0x54,0x33,0x30,0x30,0x38,0x20,0x3D,0x20,0x55,0x6E,0x75,0x73,
-	0x65,0x64,0x16,0x3E,0x31,0x20,0x3D,0x20,0x2D,0x31,0x20,0x20,
-	0x20,0x20,0x40,0x54,0x33,0x30,0x30,0x39,0x20,0x3D,0x20,0x2B,
-	0x31,0x16,0x3E,0x32,0x20,0x3D,0x20,0x2D,0x32,0x20,0x20,0x20,
-	0x20,0x40,0x54,0x33,0x30,0x30,0x41,0x20,0x3D,0x20,0x2B,0x32,
-	0x16,0x3E,0x33,0x20,0x3D,0x20,0x2D,0x34,0x20,0x20,0x20,0x20,
-	0x40,0x54,0x33,0x30,0x30,0x42,0x20,0x3D,0x20,0x2B,0x34,0x16,
-	0x3E,0x34,0x20,0x3D,0x20,0x2D,0x38,0x20,0x20,0x20,0x20,0x40,
-	0x54,0x33,0x30,0x30,0x43,0x20,0x3D,0x20,0x2B,0x38,0x17,0x3E,
-	0x35,0x20,0x3D,0x20,0x2D,0x31,0x36,0x20,0x20,0x20,0x40,0x54,
-	0x33,0x30,0x30,0x44,0x20,0x3D,0x20,0x2B,0x31,0x36,0x18,0x3E,
-	0x36,0x20,0x3D,0x20,0x2A,0x32,0x2F,0x33,0x20,0x20,0x40,0x54,
-	0x33,0x30,0x30,0x45,0x20,0x3D,0x20,0x2A,0x33,0x2F,0x32,0x16,
-	0x3E,0x37,0x20,0x3D,0x20,0x2A,0x31,0x2F,0x32,0x20,0x20,0x40,
-	0x54,0x33,0x30,0x30,0x46,0x20,0x3D,0x20,0x2A,0x32,0x00,0x10,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x54,0x72,
-	0x65,0x6D,0x6F,0x72,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x43,0x30,0x30,0x32,0x1E,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,
-	0x20,0x54,0x20,0x2B,0x20,0x4F,0x6E,0x20,0x74,0x69,0x6D,0x65,
-	0x20,0x2B,0x20,0x4F,0x66,0x66,0x20,0x74,0x69,0x6D,0x65,0x00,
-	0x3E,0x54,0x68,0x69,0x73,0x20,0x77,0x65,0x69,0x72,0x64,0x20,
 	0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x77,0x69,0x6C,0x6C,
-	0x20,0x73,0x65,0x74,0x20,0x74,0x68,0x65,0x20,0x76,0x6F,0x6C,
+	0x20,0x73,0x65,0x74,0x20,0x74,0x68,0x65,0x20,0x73,0x70,0x65,
-	0x75,0x6D,0x65,0x20,0x74,0x6F,0x20,0x7A,0x65,0x72,0x6F,0x20,
+	0x65,0x64,0x20,0x6F,0x72,0x20,0x42,0x50,0x4D,0x20,0x76,0x61,
-	0x64,0x75,0x72,0x69,0x6E,0x67,0x20,0x6F,0x66,0x66,0x20,0x74,
+	0x6C,0x75,0x65,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x73,
-	0x69,0x6D,0x65,0x36,0x6E,0x75,0x6D,0x62,0x65,0x72,0x20,0x6F,
+	0x6F,0x6E,0x67,0x2E,0x20,0x49,0x66,0x20,0x76,0x61,0x6C,0x75,
-	0x66,0x20,0x74,0x69,0x63,0x6B,0x73,0x2E,0x20,0x49,0x74,0x20,
+	0x65,0x3F,0x69,0x73,0x20,0x6C,0x65,0x73,0x73,0x20,0x74,0x68,
-	0x69,0x73,0x20,0x69,0x6E,0x63,0x6C,0x75,0x64,0x65,0x64,0x20,
+	0x61,0x6E,0x20,0x24,0x32,0x30,0x2C,0x20,0x74,0x68,0x65,0x20,
-	0x66,0x6F,0x72,0x20,0x53,0x54,0x4D,0x20,0x63,0x6F,0x6D,0x70,
+	0x73,0x70,0x65,0x65,0x64,0x20,0x77,0x69,0x6C,0x6C,0x20,0x62,
-	0x61,0x74,0x69,0x62,0x69,0x6C,0x69,0x74,0x79,0x2E,0x00,0x27,
+	0x65,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x64,0x2E,0x20,0x4F,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x45,0x78,
+	0x74,0x68,0x65,0x72,0x77,0x69,0x73,0x65,0x2C,0x20,0x74,0x68,
-	0x74,0x72,0x61,0x20,0x66,0x69,0x6E,0x65,0x20,0x70,0x6F,0x72,
+	0x65,0x20,0x42,0x50,0x4D,0x16,0x76,0x61,0x6C,0x75,0x65,0x20,
-	0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x75,0x70,0x2F,0x64,
+	0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x63,0x68,0x61,0x6E,
-	0x6F,0x77,0x6E,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
+	0x67,0x65,0x64,0x2E,0x00,0x1B,0x40,0x58,0x30,0x34,0x30,0x40,
-	0x30,0x30,0x32,0x19,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,
+	0x43,0x30,0x30,0x31,0x53,0x65,0x74,0x20,0x67,0x6C,0x6F,0x62,
-	0x58,0x28,0x31,0x20,0x6F,0x72,0x20,0x32,0x29,0x20,0x2B,0x20,
+	0x61,0x6C,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x0B,0x3E,0x40,
-	0x53,0x70,0x65,0x65,0x64,0x00,0x3C,0x54,0x68,0x69,0x73,0x20,
+	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x12,0x53,0x79,
+	0x6E,0x74,0x61,0x78,0x3A,0x20,0x47,0x20,0x2B,0x20,0x76,0x6F,
+	0x6C,0x75,0x6D,0x65,0x00,0x42,0x53,0x65,0x74,0x73,0x20,0x74,
+	0x68,0x65,0x20,0x67,0x6C,0x6F,0x62,0x61,0x6C,0x20,0x76,0x6F,
+	0x6C,0x75,0x6D,0x65,0x2E,0x20,0x54,0x68,0x65,0x20,0x76,0x6F,
+	0x6C,0x75,0x6D,0x65,0x20,0x73,0x68,0x6F,0x75,0x6C,0x64,0x20,
+	0x6E,0x6F,0x74,0x20,0x62,0x65,0x20,0x67,0x72,0x65,0x61,0x74,
+	0x65,0x72,0x20,0x74,0x68,0x61,0x6E,0x20,0x24,0x34,0x30,0x2E,
+	0x00,0x1D,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
+	0x47,0x6C,0x6F,0x62,0x61,0x6C,0x20,0x76,0x6F,0x6C,0x75,0x6D,
+	0x65,0x20,0x73,0x6C,0x69,0x64,0x65,0x0B,0x3E,0x40,0x58,0x30,
+	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x21,0x53,0x79,0x6E,0x74,
+	0x61,0x78,0x3A,0x20,0x48,0x20,0x2B,0x20,0x55,0x70,0x20,0x73,
+	0x70,0x65,0x65,0x64,0x20,0x2B,0x20,0x44,0x6F,0x77,0x6E,0x20,
+	0x73,0x70,0x65,0x65,0x64,0x00,0x3D,0x54,0x68,0x69,0x73,0x20,
 	0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x77,0x6F,0x72,0x6B,
-	0x73,0x20,0x61,0x73,0x20,0x66,0x69,0x6E,0x65,0x20,0x70,0x6F,
+	0x73,0x20,0x65,0x78,0x61,0x63,0x74,0x6C,0x79,0x20,0x61,0x73,
-	0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,0x75,0x70,0x2F,
+	0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x73,0x6C,0x69,0x64,
-	0x64,0x6F,0x77,0x6E,0x2C,0x20,0x62,0x75,0x74,0x20,0x74,0x68,
+	0x65,0x2C,0x20,0x62,0x75,0x74,0x20,0x69,0x74,0x20,0x73,0x6C,
-	0x65,0x20,0x73,0x70,0x65,0x65,0x64,0x18,0x77,0x69,0x6C,0x6C,
+	0x69,0x64,0x65,0x73,0x20,0x74,0x68,0x65,0x16,0x67,0x6C,0x6F,
-	0x20,0x62,0x65,0x20,0x64,0x69,0x76,0x69,0x64,0x65,0x64,0x20,
+	0x62,0x61,0x6C,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x69,
-	0x62,0x79,0x20,0x66,0x6F,0x75,0x72,0x2E,0x00,0x03,0x45,0x4E,
+	0x6E,0x73,0x74,0x65,0x61,0x64,0x2E,0x00,0x11,0x40,0x58,0x30,
-	0x44,0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
+	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x4B,0x65,0x79,0x20,0x6F,
+	0x66,0x66,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
+	0x30,0x32,0x10,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x4B,
+	0x20,0x2B,0x20,0x54,0x69,0x63,0x6B,0x00,0x3C,0x54,0x68,0x69,
+	0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,0x77,0x69,
+	0x6C,0x6C,0x20,0x74,0x72,0x69,0x67,0x67,0x65,0x72,0x20,0x61,
+	0x20,0x22,0x4B,0x65,0x79,0x20,0x6F,0x66,0x66,0x22,0x20,0x61,
+	0x74,0x20,0x74,0x68,0x65,0x20,0x73,0x70,0x65,0x63,0x69,0x66,
+	0x69,0x65,0x64,0x20,0x74,0x69,0x63,0x6B,0x2E,0x00,0x1F,0x40,
+	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x65,0x74,
+	0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x20,0x70,0x6F,
+	0x73,0x69,0x74,0x69,0x6F,0x6E,0x0B,0x3E,0x40,0x58,0x30,0x36,
+	0x30,0x40,0x43,0x30,0x30,0x32,0x14,0x53,0x79,0x6E,0x74,0x61,
+	0x78,0x3A,0x20,0x4C,0x20,0x2B,0x20,0x50,0x6F,0x73,0x69,0x74,
+	0x69,0x6F,0x6E,0x00,0x3E,0x43,0x68,0x61,0x6E,0x67,0x65,0x73,
+	0x20,0x74,0x68,0x65,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,
+	0x65,0x20,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x2E,0x20,
+	0x4D,0x61,0x67,0x6E,0x75,0x73,0x20,0x74,0x6F,0x6C,0x64,0x20,
+	0x6D,0x65,0x20,0x74,0x68,0x61,0x74,0x20,0x69,0x74,0x20,0x77,
+	0x6F,0x75,0x6C,0x64,0x20,0x62,0x65,0x0C,0x76,0x65,0x72,0x79,
+	0x20,0x75,0x73,0x61,0x62,0x6C,0x65,0x2E,0x00,0x17,0x40,0x58,
+	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x50,0x61,0x6E,0x6E,
+	0x69,0x6E,0x67,0x20,0x73,0x6C,0x69,0x64,0x65,0x0B,0x3E,0x40,
+	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x24,0x53,0x79,
+	0x6E,0x74,0x61,0x78,0x3A,0x20,0x50,0x20,0x2B,0x20,0x52,0x69,
+	0x67,0x68,0x74,0x20,0x73,0x70,0x65,0x65,0x64,0x20,0x2B,0x20,
+	0x4C,0x65,0x66,0x74,0x20,0x73,0x70,0x65,0x65,0x64,0x00,0x42,
+	0x54,0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,
+	0x20,0x73,0x6C,0x69,0x64,0x65,0x73,0x20,0x74,0x68,0x65,0x20,
+	0x70,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x70,0x6F,0x73,0x69,
+	0x74,0x69,0x6F,0x6E,0x2E,0x20,0x49,0x74,0x20,0x77,0x6F,0x72,
+	0x6B,0x73,0x20,0x6C,0x69,0x6B,0x65,0x20,0x74,0x68,0x65,0x20,
+	0x76,0x6F,0x6C,0x75,0x6D,0x65,0x3C,0x73,0x6C,0x69,0x64,0x65,
+	0x2E,0x20,0x4E,0x6F,0x74,0x65,0x20,0x74,0x68,0x61,0x74,0x20,
+	0x73,0x6F,0x6D,0x65,0x20,0x73,0x6F,0x75,0x6E,0x64,0x20,0x63,
+	0x61,0x72,0x64,0x73,0x20,0x6D,0x61,0x79,0x20,0x6E,0x6F,0x74,
+	0x20,0x68,0x61,0x6E,0x64,0x6C,0x65,0x20,0x32,0x35,0x36,0x20,
+	0x70,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x0A,0x70,0x6F,0x73,0x69,
+	0x74,0x69,0x6F,0x6E,0x73,0x2E,0x00,0x16,0x40,0x58,0x30,0x34,
+	0x30,0x40,0x43,0x30,0x30,0x31,0x4D,0x75,0x6C,0x74,0x69,0x20,
+	0x72,0x65,0x74,0x72,0x69,0x67,0x0B,0x3E,0x40,0x58,0x30,0x36,
+	0x30,0x40,0x43,0x30,0x30,0x32,0x24,0x53,0x79,0x6E,0x74,0x61,
+	0x78,0x3A,0x20,0x52,0x20,0x2B,0x20,0x56,0x6F,0x6C,0x75,0x6D,
+	0x65,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x20,0x2B,0x20,0x49,
+	0x6E,0x74,0x65,0x72,0x76,0x61,0x6C,0x00,0x32,0x54,0x68,0x69,
+	0x73,0x20,0x69,0x73,0x20,0x61,0x6E,0x20,0x65,0x78,0x74,0x65,
+	0x6E,0x64,0x65,0x64,0x20,0x76,0x65,0x72,0x73,0x69,0x6F,0x6E,
+	0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x72,0x65,0x74,0x72,
+	0x69,0x67,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x2E,0x00,
+	0x0E,0x56,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x63,0x68,0x61,0x6E,
+	0x67,0x65,0x3A,0x1F,0x3E,0x40,0x58,0x31,0x30,0x30,0x30,0x20,
+	0x3D,0x20,0x4E,0x6F,0x6E,0x65,0x20,0x20,0x40,0x54,0x33,0x30,
+	0x30,0x38,0x20,0x3D,0x20,0x55,0x6E,0x75,0x73,0x65,0x64,0x16,
+	0x3E,0x31,0x20,0x3D,0x20,0x2D,0x31,0x20,0x20,0x20,0x20,0x40,
+	0x54,0x33,0x30,0x30,0x39,0x20,0x3D,0x20,0x2B,0x31,0x16,0x3E,
+	0x32,0x20,0x3D,0x20,0x2D,0x32,0x20,0x20,0x20,0x20,0x40,0x54,
+	0x33,0x30,0x30,0x41,0x20,0x3D,0x20,0x2B,0x32,0x16,0x3E,0x33,
+	0x20,0x3D,0x20,0x2D,0x34,0x20,0x20,0x20,0x20,0x40,0x54,0x33,
+	0x30,0x30,0x42,0x20,0x3D,0x20,0x2B,0x34,0x16,0x3E,0x34,0x20,
+	0x3D,0x20,0x2D,0x38,0x20,0x20,0x20,0x20,0x40,0x54,0x33,0x30,
+	0x30,0x43,0x20,0x3D,0x20,0x2B,0x38,0x17,0x3E,0x35,0x20,0x3D,
+	0x20,0x2D,0x31,0x36,0x20,0x20,0x20,0x40,0x54,0x33,0x30,0x30,
+	0x44,0x20,0x3D,0x20,0x2B,0x31,0x36,0x18,0x3E,0x36,0x20,0x3D,
+	0x20,0x2A,0x32,0x2F,0x33,0x20,0x20,0x40,0x54,0x33,0x30,0x30,
+	0x45,0x20,0x3D,0x20,0x2A,0x33,0x2F,0x32,0x16,0x3E,0x37,0x20,
+	0x3D,0x20,0x2A,0x31,0x2F,0x32,0x20,0x20,0x40,0x54,0x33,0x30,
+	0x30,0x46,0x20,0x3D,0x20,0x2A,0x32,0x00,0x10,0x40,0x58,0x30,
+	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x54,0x72,0x65,0x6D,0x6F,
+	0x72,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,
+	0x32,0x1E,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x54,0x20,
+	0x2B,0x20,0x4F,0x6E,0x20,0x74,0x69,0x6D,0x65,0x20,0x2B,0x20,
+	0x4F,0x66,0x66,0x20,0x74,0x69,0x6D,0x65,0x00,0x3E,0x54,0x68,
+	0x69,0x73,0x20,0x77,0x65,0x69,0x72,0x64,0x20,0x63,0x6F,0x6D,
+	0x6D,0x61,0x6E,0x64,0x20,0x77,0x69,0x6C,0x6C,0x20,0x73,0x65,
+	0x74,0x20,0x74,0x68,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,
+	0x20,0x74,0x6F,0x20,0x7A,0x65,0x72,0x6F,0x20,0x64,0x75,0x72,
+	0x69,0x6E,0x67,0x20,0x6F,0x66,0x66,0x20,0x74,0x69,0x6D,0x65,
+	0x36,0x6E,0x75,0x6D,0x62,0x65,0x72,0x20,0x6F,0x66,0x20,0x74,
+	0x69,0x63,0x6B,0x73,0x2E,0x20,0x49,0x74,0x20,0x69,0x73,0x20,
+	0x69,0x6E,0x63,0x6C,0x75,0x64,0x65,0x64,0x20,0x66,0x6F,0x72,
+	0x20,0x53,0x54,0x4D,0x20,0x63,0x6F,0x6D,0x70,0x61,0x74,0x69,
+	0x62,0x69,0x6C,0x69,0x74,0x79,0x2E,0x00,0x27,0x40,0x58,0x30,
+	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x45,0x78,0x74,0x72,0x61,
+	0x20,0x66,0x69,0x6E,0x65,0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,
+	0x65,0x6E,0x74,0x6F,0x20,0x75,0x70,0x2F,0x64,0x6F,0x77,0x6E,
+	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
+	0x19,0x53,0x79,0x6E,0x74,0x61,0x78,0x3A,0x20,0x58,0x28,0x31,
+	0x20,0x6F,0x72,0x20,0x32,0x29,0x20,0x2B,0x20,0x53,0x70,0x65,
+	0x65,0x64,0x00,0x3C,0x54,0x68,0x69,0x73,0x20,0x63,0x6F,0x6D,
+	0x6D,0x61,0x6E,0x64,0x20,0x77,0x6F,0x72,0x6B,0x73,0x20,0x61,
+	0x73,0x20,0x66,0x69,0x6E,0x65,0x20,0x70,0x6F,0x72,0x74,0x61,
+	0x6D,0x65,0x6E,0x74,0x6F,0x20,0x75,0x70,0x2F,0x64,0x6F,0x77,
+	0x6E,0x2C,0x20,0x62,0x75,0x74,0x20,0x74,0x68,0x65,0x20,0x73,
+	0x70,0x65,0x65,0x64,0x18,0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,
+	0x20,0x64,0x69,0x76,0x69,0x64,0x65,0x64,0x20,0x62,0x79,0x20,
+	0x66,0x6F,0x75,0x72,0x2E,0x00,0x03,0x45,0x4E,0x44,0x4C,0x3B,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
-	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
+	0x2A,0x2A,0x2A,0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
-	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x0A,
+	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
-	0x40,0x4C,0x4B,0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x00,0x0B,
+	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x0A,0x40,0x4C,0x4B,
-	0x3E,0x40,0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x32,0x4A,
+	0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x00,0x0B,0x3E,0x40,0x58,
-	0x3E,0x49,0x66,0x20,0x79,0x6F,0x75,0x20,0x68,0x61,0x76,0x65,
+	0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x32,0x4A,0x3E,0x49,0x66,
-	0x20,0x61,0x6E,0x20,0x61,0x6D,0x62,0x69,0x74,0x69,0x6F,0x6E,
+	0x20,0x79,0x6F,0x75,0x20,0x68,0x61,0x76,0x65,0x20,0x61,0x6E,
-	0x20,0x74,0x6F,0x20,0x63,0x72,0x65,0x61,0x74,0x65,0x20,0x6D,
+	0x20,0x61,0x6D,0x62,0x69,0x74,0x69,0x6F,0x6E,0x20,0x74,0x6F,
-	0x75,0x73,0x69,0x63,0x20,0x65,0x66,0x66,0x69,0x63,0x69,0x65,
+	0x20,0x63,0x72,0x65,0x61,0x74,0x65,0x20,0x6D,0x75,0x73,0x69,
-	0x6E,0x74,0x6C,0x79,0x20,0x77,0x65,0x20,0x73,0x74,0x72,0x6F,
+	0x63,0x20,0x65,0x66,0x66,0x69,0x63,0x69,0x65,0x6E,0x74,0x6C,
-	0x6E,0x67,0x6C,0x79,0x20,0x72,0x65,0x63,0x6F,0x6D,0x6D,0x65,
+	0x79,0x20,0x77,0x65,0x20,0x73,0x74,0x72,0x6F,0x6E,0x67,0x6C,
-	0x6E,0x64,0x44,0x74,0x68,0x61,0x74,0x20,0x79,0x6F,0x75,0x20,
+	0x79,0x20,0x72,0x65,0x63,0x6F,0x6D,0x6D,0x65,0x6E,0x64,0x44,
-	0x6C,0x65,0x61,0x72,0x6E,0x20,0x41,0x4C,0x4C,0x20,0x74,0x68,
+	0x74,0x68,0x61,0x74,0x20,0x79,0x6F,0x75,0x20,0x6C,0x65,0x61,
-	0x65,0x20,0x6B,0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x20,0x66,
+	0x72,0x6E,0x20,0x41,0x4C,0x4C,0x20,0x74,0x68,0x65,0x20,0x6B,
-	0x75,0x6E,0x63,0x74,0x69,0x6F,0x6E,0x73,0x2E,0x20,0x4D,0x61,
+	0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x20,0x66,0x75,0x6E,0x63,
-	0x6E,0x79,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x6D,0x20,0x61,
+	0x74,0x69,0x6F,0x6E,0x73,0x2E,0x20,0x4D,0x61,0x6E,0x79,0x20,
-	0x72,0x65,0x20,0x74,0x68,0x65,0x20,0x73,0x61,0x6D,0x65,0x45,
+	0x6F,0x66,0x20,0x74,0x68,0x65,0x6D,0x20,0x61,0x72,0x65,0x20,
-	0x66,0x72,0x6F,0x6D,0x20,0x46,0x61,0x73,0x74,0x74,0x72,0x61,
+	0x74,0x68,0x65,0x20,0x73,0x61,0x6D,0x65,0x45,0x66,0x72,0x6F,
-	0x63,0x6B,0x65,0x72,0x20,0x31,0x20,0x61,0x6E,0x64,0x20,0x50,
+	0x6D,0x20,0x46,0x61,0x73,0x74,0x74,0x72,0x61,0x63,0x6B,0x65,
-	0x72,0x6F,0x54,0x72,0x61,0x63,0x6B,0x65,0x72,0x20,0x74,0x6F,
+	0x72,0x20,0x31,0x20,0x61,0x6E,0x64,0x20,0x50,0x72,0x6F,0x54,
-	0x20,0x65,0x6E,0x73,0x75,0x72,0x65,0x20,0x74,0x68,0x61,0x74,
+	0x72,0x61,0x63,0x6B,0x65,0x72,0x20,0x74,0x6F,0x20,0x65,0x6E,
-	0x20,0x79,0x6F,0x75,0x20,0x66,0x65,0x65,0x6C,0x20,0x63,0x6F,
+	0x73,0x75,0x72,0x65,0x20,0x74,0x68,0x61,0x74,0x20,0x79,0x6F,
-	0x6D,0x66,0x6F,0x72,0x74,0x61,0x62,0x6C,0x65,0x2E,0x75,0x73,
+	0x75,0x20,0x66,0x65,0x65,0x6C,0x20,0x63,0x6F,0x6D,0x66,0x6F,
-	0x69,0x6E,0x67,0x20,0x74,0x68,0x69,0x73,0x20,0x70,0x72,0x6F,
+	0x72,0x74,0x61,0x62,0x6C,0x65,0x2E,0x75,0x73,0x69,0x6E,0x67,
-	0x67,0x72,0x61,0x6D,0x20,0x66,0x72,0x6F,0x6D,0x20,0x74,0x68,
+	0x20,0x74,0x68,0x69,0x73,0x20,0x70,0x72,0x6F,0x67,0x72,0x61,
-	0x65,0x20,0x76,0x65,0x72,0x79,0x20,0x66,0x69,0x72,0x73,0x74,
+	0x6D,0x20,0x66,0x72,0x6F,0x6D,0x20,0x74,0x68,0x65,0x20,0x76,
-	0x20,0x6D,0x69,0x6E,0x75,0x74,0x65,0x2E,0x01,0x3E,0x0B,0x3E,
+	0x65,0x72,0x79,0x20,0x66,0x69,0x72,0x73,0x74,0x20,0x6D,0x69,
-	0x40,0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x31,0x26,0x3E,
+	0x6E,0x75,0x74,0x65,0x2E,0x01,0x3E,0x0B,0x3E,0x40,0x58,0x30,
-	0x59,0x6F,0x75,0x20,0x73,0x68,0x6F,0x75,0x6C,0x64,0x20,0x62,
+	0x32,0x30,0x40,0x43,0x30,0x30,0x31,0x26,0x3E,0x59,0x6F,0x75,
-	0x65,0x20,0x61,0x77,0x61,0x72,0x65,0x20,0x6F,0x66,0x20,0x74,
+	0x20,0x73,0x68,0x6F,0x75,0x6C,0x64,0x20,0x62,0x65,0x20,0x61,
-	0x68,0x65,0x20,0x66,0x61,0x63,0x74,0x20,0x74,0x68,0x61,0x74,
+	0x77,0x61,0x72,0x65,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,
-	0x3A,0x01,0x3E,0x48,0x3E,0x40,0x43,0x30,0x30,0x32,0x54,0x68,
+	0x66,0x61,0x63,0x74,0x20,0x74,0x68,0x61,0x74,0x3A,0x01,0x3E,
-	0x69,0x73,0x20,0x68,0x65,0x6C,0x70,0x20,0x74,0x65,0x78,0x74,
+	0x48,0x3E,0x40,0x43,0x30,0x30,0x32,0x54,0x68,0x69,0x73,0x20,
-	0x20,0x69,0x73,0x20,0x77,0x72,0x69,0x74,0x74,0x65,0x6E,0x20,
+	0x68,0x65,0x6C,0x70,0x20,0x74,0x65,0x78,0x74,0x20,0x69,0x73,
-	0x75,0x73,0x69,0x6E,0x67,0x20,0x61,0x20,0x53,0x77,0x65,0x64,
+	0x20,0x77,0x72,0x69,0x74,0x74,0x65,0x6E,0x20,0x75,0x73,0x69,
-	0x69,0x73,0x68,0x20,0x6B,0x65,0x79,0x62,0x6F,0x61,0x72,0x64,
+	0x6E,0x67,0x20,0x61,0x20,0x53,0x77,0x65,0x64,0x69,0x73,0x68,
-	0x2E,0x20,0x54,0x68,0x65,0x72,0x65,0x66,0x6F,0x72,0x65,0x20,
+	0x20,0x6B,0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x2E,0x20,0x54,
-	0x73,0x6F,0x6D,0x65,0x2F,0x72,0x65,0x66,0x65,0x72,0x65,0x6E,
+	0x68,0x65,0x72,0x65,0x66,0x6F,0x72,0x65,0x20,0x73,0x6F,0x6D,
-	0x63,0x65,0x73,0x20,0x74,0x6F,0x20,0x6E,0x6F,0x6E,0x2D,0x6F,
+	0x65,0x2F,0x72,0x65,0x66,0x65,0x72,0x65,0x6E,0x63,0x65,0x73,
-	0x72,0x64,0x69,0x6E,0x61,0x72,0x79,0x20,0x6B,0x65,0x79,0x73,
+	0x20,0x74,0x6F,0x20,0x6E,0x6F,0x6E,0x2D,0x6F,0x72,0x64,0x69,
-	0x20,0x6D,0x69,0x67,0x68,0x74,0x20,0x62,0x65,0x20,0x77,0x72,
+	0x6E,0x61,0x72,0x79,0x20,0x6B,0x65,0x79,0x73,0x20,0x6D,0x69,
-	0x6F,0x6E,0x67,0x2E,0x0F,0x53,0x68,0x20,0x3D,0x20,0x73,0x68,
+	0x67,0x68,0x74,0x20,0x62,0x65,0x20,0x77,0x72,0x6F,0x6E,0x67,
-	0x69,0x66,0x74,0x20,0x6B,0x65,0x79,0x2E,0x01,0x3E,0x10,0x40,
+	0x2E,0x0F,0x53,0x68,0x20,0x3D,0x20,0x73,0x68,0x69,0x66,0x74,
-	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x56,0x69,0x64,
+	0x20,0x6B,0x65,0x79,0x2E,0x01,0x3E,0x10,0x40,0x58,0x30,0x34,
-	0x65,0x6F,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
+	0x30,0x40,0x43,0x30,0x30,0x31,0x56,0x69,0x64,0x65,0x6F,0x3A,
-	0x30,0x30,0x32,0x25,0x41,0x6C,0x74,0x2B,0x45,0x6E,0x74,0x65,
-	0x72,0x20,0x40,0x54,0x31,0x36,0x30,0x54,0x6F,0x67,0x67,0x6C,
-	0x65,0x20,0x66,0x75,0x6C,0x6C,0x73,0x63,0x72,0x65,0x65,0x6E,
-	0x20,0x6D,0x6F,0x64,0x65,0x01,0x3E,0x2C,0x3E,0x28,0x4F,0x72,
-	0x20,0x22,0x4C,0x65,0x66,0x74,0x20,0x43,0x74,0x72,0x6C,0x20,
-	0x2B,0x20,0x4C,0x65,0x66,0x74,0x20,0x43,0x6F,0x6D,0x6D,0x61,
-	0x6E,0x64,0x20,0x2B,0x20,0x46,0x22,0x20,0x6F,0x6E,0x20,0x4D,
-	0x61,0x63,0x73,0x29,0x00,0x17,0x40,0x58,0x30,0x34,0x30,0x40,
-	0x43,0x30,0x30,0x31,0x43,0x75,0x72,0x73,0x6F,0x72,0x20,0x6D,
-	0x6F,0x76,0x65,0x73,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,
-	0x40,0x43,0x30,0x30,0x32,0x1D,0x46,0x39,0x2E,0x2E,0x46,0x31,
-	0x32,0x20,0x40,0x54,0x31,0x36,0x30,0x4A,0x75,0x6D,0x70,0x20,
-	0x69,0x6E,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x32,
-	0x3E,0x43,0x74,0x72,0x6C,0x2B,0x46,0x39,0x2E,0x2E,0x46,0x31,
-	0x32,0x20,0x40,0x54,0x31,0x36,0x30,0x50,0x61,0x74,0x74,0x65,
-	0x72,0x6E,0x2D,0x70,0x6C,0x61,0x79,0x20,0x66,0x72,0x6F,0x6D,
-	0x20,0x46,0x39,0x2E,0x2E,0x46,0x31,0x32,0x20,0x6C,0x69,0x6E,
-	0x65,0x2E,0x2F,0x3E,0x53,0x68,0x2B,0x46,0x39,0x2E,0x2E,0x46,
-	0x31,0x32,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x74,0x6F,0x72,
-	0x65,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x6C,0x69,
-	0x6E,0x65,0x20,0x69,0x6E,0x20,0x46,0x39,0x2E,0x2E,0x46,0x31,
-	0x32,0x2E,0x24,0x3E,0x50,0x61,0x67,0x65,0x55,0x70,0x20,0x20,
-	0x40,0x54,0x31,0x36,0x30,0x4A,0x75,0x6D,0x70,0x20,0x31,0x36,
-	0x2D,0x6C,0x69,0x6E,0x65,0x73,0x20,0x75,0x70,0x77,0x61,0x72,
-	0x64,0x73,0x2E,0x27,0x3E,0x50,0x61,0x67,0x65,0x44,0x6F,0x77,
-	0x6E,0x20,0x40,0x54,0x31,0x36,0x30,0x4A,0x75,0x6D,0x70,0x20,
-	0x31,0x36,0x2D,0x6C,0x69,0x6E,0x65,0x73,0x20,0x64,0x6F,0x77,
-	0x6E,0x77,0x61,0x72,0x64,0x73,0x2E,0x1B,0x3E,0x48,0x6F,0x6D,
-	0x65,0x20,0x20,0x40,0x54,0x31,0x36,0x30,0x4A,0x75,0x6D,0x70,
-	0x20,0x74,0x6F,0x20,0x6C,0x69,0x6E,0x65,0x20,0x30,0x2E,0x1D,
-	0x3E,0x45,0x6E,0x64,0x20,0x20,0x40,0x54,0x31,0x36,0x30,0x4A,
-	0x75,0x6D,0x70,0x20,0x74,0x6F,0x20,0x6C,0x61,0x73,0x74,0x20,
-	0x6C,0x69,0x6E,0x65,0x2E,0x1E,0x3E,0x54,0x61,0x62,0x20,0x20,
-	0x40,0x54,0x31,0x36,0x30,0x4A,0x75,0x6D,0x70,0x20,0x74,0x6F,
-	0x20,0x6E,0x65,0x78,0x74,0x20,0x74,0x72,0x61,0x63,0x6B,0x2E,
-	0x33,0x3E,0x41,0x6C,0x74,0x2B,0x51,0x2E,0x2E,0x49,0x20,0x40,
-	0x54,0x31,0x36,0x30,0x4A,0x75,0x6D,0x70,0x20,0x74,0x6F,0x20,
-	0x74,0x72,0x61,0x63,0x6B,0x20,0x28,0x30,0x2E,0x2E,0x37,0x29,
-	0x20,0x4D,0x4F,0x44,0x20,0x4E,0x2D,0x43,0x68,0x61,0x6E,0x6E,
-	0x65,0x6C,0x73,0x2E,0x34,0x3E,0x41,0x6C,0x74,0x2B,0x41,0x2E,
-	0x2E,0x4B,0x20,0x40,0x54,0x31,0x36,0x30,0x4A,0x75,0x6D,0x70,
-	0x20,0x74,0x6F,0x20,0x74,0x72,0x61,0x63,0x6B,0x20,0x28,0x38,
-	0x2E,0x2E,0x31,0x35,0x29,0x20,0x4D,0x4F,0x44,0x20,0x4E,0x2D,
-	0x43,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x73,0x2E,0x00,0x19,0x40,
-	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x43,0x75,0x74,
-	0x2F,0x43,0x6F,0x70,0x79,0x2F,0x50,0x61,0x73,0x74,0x65,0x3A,
 	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
-	0x34,0x44,0x65,0x6C,0x65,0x74,0x65,0x20,0x20,0x40,0x54,0x31,
+	0x25,0x41,0x6C,0x74,0x2B,0x45,0x6E,0x74,0x65,0x72,0x20,0x40,
-	0x36,0x30,0x44,0x65,0x6C,0x65,0x74,0x65,0x20,0x6E,0x6F,0x74,
+	0x54,0x31,0x36,0x30,0x54,0x6F,0x67,0x67,0x6C,0x65,0x20,0x66,
-	0x65,0x20,0x6F,0x72,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,
+	0x75,0x6C,0x6C,0x73,0x63,0x72,0x65,0x65,0x6E,0x20,0x6D,0x6F,
-	0x63,0x6F,0x6C,0x75,0x6D,0x6E,0x20,0x61,0x74,0x20,0x63,0x75,
+	0x64,0x65,0x01,0x3E,0x2C,0x3E,0x28,0x4F,0x72,0x20,0x22,0x4C,
-	0x72,0x73,0x6F,0x72,0x2E,0x39,0x3E,0x53,0x68,0x2B,0x44,0x65,
+	0x65,0x66,0x74,0x20,0x43,0x74,0x72,0x6C,0x20,0x2B,0x20,0x4C,
-	0x6C,0x65,0x74,0x65,0x20,0x40,0x54,0x31,0x36,0x30,0x44,0x65,
+	0x65,0x66,0x74,0x20,0x43,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x20,
-	0x6C,0x65,0x74,0x65,0x20,0x6E,0x6F,0x74,0x65,0x2C,0x20,0x76,
+	0x2B,0x20,0x46,0x22,0x20,0x6F,0x6E,0x20,0x4D,0x61,0x63,0x73,
-	0x6F,0x6C,0x75,0x6D,0x65,0x20,0x61,0x6E,0x64,0x20,0x65,0x66,
+	0x29,0x00,0x17,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
-	0x66,0x65,0x63,0x74,0x20,0x61,0x74,0x20,0x63,0x75,0x72,0x73,
+	0x31,0x43,0x75,0x72,0x73,0x6F,0x72,0x20,0x6D,0x6F,0x76,0x65,
-	0x6F,0x72,0x2E,0x35,0x3E,0x43,0x74,0x72,0x6C,0x2B,0x44,0x65,
+	0x73,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
-	0x6C,0x65,0x74,0x65,0x20,0x40,0x54,0x31,0x36,0x30,0x44,0x65,
+	0x30,0x32,0x1D,0x46,0x39,0x2E,0x2E,0x46,0x31,0x32,0x20,0x40,
-	0x6C,0x65,0x74,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,
+	0x54,0x31,0x36,0x30,0x4A,0x75,0x6D,0x70,0x20,0x69,0x6E,0x20,
-	0x61,0x6E,0x64,0x20,0x65,0x66,0x66,0x65,0x63,0x74,0x20,0x61,
+	0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x32,0x3E,0x43,0x74,
-	0x74,0x20,0x63,0x75,0x72,0x73,0x6F,0x72,0x2E,0x29,0x3E,0x41,
+	0x72,0x6C,0x2B,0x46,0x39,0x2E,0x2E,0x46,0x31,0x32,0x20,0x40,
-	0x6C,0x74,0x2B,0x44,0x65,0x6C,0x65,0x74,0x65,0x20,0x40,0x54,
+	0x54,0x31,0x36,0x30,0x50,0x61,0x74,0x74,0x65,0x72,0x6E,0x2D,
-	0x31,0x36,0x30,0x44,0x65,0x6C,0x65,0x74,0x65,0x20,0x65,0x66,
+	0x70,0x6C,0x61,0x79,0x20,0x66,0x72,0x6F,0x6D,0x20,0x46,0x39,
-	0x66,0x65,0x63,0x74,0x20,0x61,0x74,0x20,0x63,0x75,0x72,0x73,
+	0x2E,0x2E,0x46,0x31,0x32,0x20,0x6C,0x69,0x6E,0x65,0x2E,0x2F,
-	0x6F,0x72,0x2E,0x24,0x3E,0x49,0x6E,0x73,0x65,0x72,0x74,0x20,
+	0x3E,0x53,0x68,0x2B,0x46,0x39,0x2E,0x2E,0x46,0x31,0x32,0x20,
-	0x20,0x40,0x54,0x31,0x36,0x30,0x49,0x6E,0x73,0x65,0x72,0x74,
+	0x40,0x54,0x31,0x36,0x30,0x53,0x74,0x6F,0x72,0x65,0x20,0x63,
-	0x20,0x6E,0x6F,0x74,0x65,0x20,0x61,0x74,0x20,0x63,0x75,0x72,
+	0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x6C,0x69,0x6E,0x65,0x20,
-	0x73,0x6F,0x72,0x2E,0x27,0x3E,0x53,0x68,0x2B,0x49,0x6E,0x73,
+	0x69,0x6E,0x20,0x46,0x39,0x2E,0x2E,0x46,0x31,0x32,0x2E,0x24,
-	0x65,0x72,0x74,0x20,0x20,0x40,0x54,0x31,0x36,0x30,0x49,0x6E,
+	0x3E,0x50,0x61,0x67,0x65,0x55,0x70,0x20,0x20,0x40,0x54,0x31,
-	0x73,0x65,0x72,0x74,0x20,0x6C,0x69,0x6E,0x65,0x20,0x61,0x74,
+	0x36,0x30,0x4A,0x75,0x6D,0x70,0x20,0x31,0x36,0x2D,0x6C,0x69,
-	0x20,0x63,0x75,0x72,0x73,0x6F,0x72,0x2E,0x25,0x3E,0x42,0x61,
+	0x6E,0x65,0x73,0x20,0x75,0x70,0x77,0x61,0x72,0x64,0x73,0x2E,
-	0x63,0x6B,0x73,0x70,0x61,0x63,0x65,0x20,0x40,0x54,0x31,0x36,
+	0x27,0x3E,0x50,0x61,0x67,0x65,0x44,0x6F,0x77,0x6E,0x20,0x40,
-	0x30,0x44,0x65,0x6C,0x65,0x74,0x65,0x20,0x70,0x72,0x65,0x76,
+	0x54,0x31,0x36,0x30,0x4A,0x75,0x6D,0x70,0x20,0x31,0x36,0x2D,
-	0x69,0x6F,0x75,0x73,0x20,0x6E,0x6F,0x74,0x65,0x2E,0x28,0x3E,
+	0x6C,0x69,0x6E,0x65,0x73,0x20,0x64,0x6F,0x77,0x6E,0x77,0x61,
-	0x53,0x68,0x2B,0x42,0x61,0x63,0x6B,0x73,0x70,0x61,0x63,0x65,
+	0x72,0x64,0x73,0x2E,0x1B,0x3E,0x48,0x6F,0x6D,0x65,0x20,0x20,
-	0x20,0x40,0x54,0x31,0x36,0x30,0x44,0x65,0x6C,0x65,0x74,0x65,
+	0x40,0x54,0x31,0x36,0x30,0x4A,0x75,0x6D,0x70,0x20,0x74,0x6F,
-	0x20,0x70,0x72,0x65,0x76,0x69,0x6F,0x75,0x73,0x20,0x6C,0x69,
+	0x20,0x6C,0x69,0x6E,0x65,0x20,0x30,0x2E,0x1D,0x3E,0x45,0x6E,
-	0x6E,0x65,0x2E,0x1C,0x3E,0x41,0x6C,0x74,0x2B,0x43,0x75,0x72,
+	0x64,0x20,0x20,0x40,0x54,0x31,0x36,0x30,0x4A,0x75,0x6D,0x70,
-	0x73,0x6F,0x72,0x20,0x40,0x54,0x31,0x36,0x30,0x4D,0x61,0x72,
+	0x20,0x74,0x6F,0x20,0x6C,0x61,0x73,0x74,0x20,0x6C,0x69,0x6E,
-	0x6B,0x20,0x62,0x6C,0x6F,0x63,0x6B,0x2E,0x16,0x3E,0x53,0x68,
+	0x65,0x2E,0x1E,0x3E,0x54,0x61,0x62,0x20,0x20,0x40,0x54,0x31,
-	0x2B,0x46,0x33,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x75,0x74,
+	0x36,0x30,0x4A,0x75,0x6D,0x70,0x20,0x74,0x6F,0x20,0x6E,0x65,
-	0x20,0x74,0x72,0x61,0x63,0x6B,0x2E,0x17,0x3E,0x53,0x68,0x2B,
+	0x78,0x74,0x20,0x74,0x72,0x61,0x63,0x6B,0x2E,0x33,0x3E,0x41,
-	0x46,0x34,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x6F,0x70,0x79,
+	0x6C,0x74,0x2B,0x51,0x2E,0x2E,0x49,0x20,0x40,0x54,0x31,0x36,
-	0x20,0x74,0x72,0x61,0x63,0x6B,0x2E,0x18,0x3E,0x53,0x68,0x2B,
+	0x30,0x4A,0x75,0x6D,0x70,0x20,0x74,0x6F,0x20,0x74,0x72,0x61,
+	0x63,0x6B,0x20,0x28,0x30,0x2E,0x2E,0x37,0x29,0x20,0x4D,0x4F,
+	0x44,0x20,0x4E,0x2D,0x43,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x73,
+	0x2E,0x34,0x3E,0x41,0x6C,0x74,0x2B,0x41,0x2E,0x2E,0x4B,0x20,
+	0x40,0x54,0x31,0x36,0x30,0x4A,0x75,0x6D,0x70,0x20,0x74,0x6F,
+	0x20,0x74,0x72,0x61,0x63,0x6B,0x20,0x28,0x38,0x2E,0x2E,0x31,
+	0x35,0x29,0x20,0x4D,0x4F,0x44,0x20,0x4E,0x2D,0x43,0x68,0x61,
+	0x6E,0x6E,0x65,0x6C,0x73,0x2E,0x00,0x19,0x40,0x58,0x30,0x34,
+	0x30,0x40,0x43,0x30,0x30,0x31,0x43,0x75,0x74,0x2F,0x43,0x6F,
+	0x70,0x79,0x2F,0x50,0x61,0x73,0x74,0x65,0x3A,0x0B,0x3E,0x40,
+	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x34,0x44,0x65,
+	0x6C,0x65,0x74,0x65,0x20,0x20,0x40,0x54,0x31,0x36,0x30,0x44,
+	0x65,0x6C,0x65,0x74,0x65,0x20,0x6E,0x6F,0x74,0x65,0x20,0x6F,
+	0x72,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x63,0x6F,0x6C,
+	0x75,0x6D,0x6E,0x20,0x61,0x74,0x20,0x63,0x75,0x72,0x73,0x6F,
+	0x72,0x2E,0x39,0x3E,0x53,0x68,0x2B,0x44,0x65,0x6C,0x65,0x74,
+	0x65,0x20,0x40,0x54,0x31,0x36,0x30,0x44,0x65,0x6C,0x65,0x74,
+	0x65,0x20,0x6E,0x6F,0x74,0x65,0x2C,0x20,0x76,0x6F,0x6C,0x75,
+	0x6D,0x65,0x20,0x61,0x6E,0x64,0x20,0x65,0x66,0x66,0x65,0x63,
+	0x74,0x20,0x61,0x74,0x20,0x63,0x75,0x72,0x73,0x6F,0x72,0x2E,
+	0x35,0x3E,0x43,0x74,0x72,0x6C,0x2B,0x44,0x65,0x6C,0x65,0x74,
+	0x65,0x20,0x40,0x54,0x31,0x36,0x30,0x44,0x65,0x6C,0x65,0x74,
+	0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x61,0x6E,0x64,
+	0x20,0x65,0x66,0x66,0x65,0x63,0x74,0x20,0x61,0x74,0x20,0x63,
+	0x75,0x72,0x73,0x6F,0x72,0x2E,0x29,0x3E,0x41,0x6C,0x74,0x2B,
+	0x44,0x65,0x6C,0x65,0x74,0x65,0x20,0x40,0x54,0x31,0x36,0x30,
+	0x44,0x65,0x6C,0x65,0x74,0x65,0x20,0x65,0x66,0x66,0x65,0x63,
+	0x74,0x20,0x61,0x74,0x20,0x63,0x75,0x72,0x73,0x6F,0x72,0x2E,
+	0x24,0x3E,0x49,0x6E,0x73,0x65,0x72,0x74,0x20,0x20,0x40,0x54,
+	0x31,0x36,0x30,0x49,0x6E,0x73,0x65,0x72,0x74,0x20,0x6E,0x6F,
+	0x74,0x65,0x20,0x61,0x74,0x20,0x63,0x75,0x72,0x73,0x6F,0x72,
+	0x2E,0x27,0x3E,0x53,0x68,0x2B,0x49,0x6E,0x73,0x65,0x72,0x74,
+	0x20,0x20,0x40,0x54,0x31,0x36,0x30,0x49,0x6E,0x73,0x65,0x72,
+	0x74,0x20,0x6C,0x69,0x6E,0x65,0x20,0x61,0x74,0x20,0x63,0x75,
+	0x72,0x73,0x6F,0x72,0x2E,0x25,0x3E,0x42,0x61,0x63,0x6B,0x73,
+	0x70,0x61,0x63,0x65,0x20,0x40,0x54,0x31,0x36,0x30,0x44,0x65,
+	0x6C,0x65,0x74,0x65,0x20,0x70,0x72,0x65,0x76,0x69,0x6F,0x75,
+	0x73,0x20,0x6E,0x6F,0x74,0x65,0x2E,0x28,0x3E,0x53,0x68,0x2B,
+	0x42,0x61,0x63,0x6B,0x73,0x70,0x61,0x63,0x65,0x20,0x40,0x54,
+	0x31,0x36,0x30,0x44,0x65,0x6C,0x65,0x74,0x65,0x20,0x70,0x72,
+	0x65,0x76,0x69,0x6F,0x75,0x73,0x20,0x6C,0x69,0x6E,0x65,0x2E,
+	0x1C,0x3E,0x41,0x6C,0x74,0x2B,0x43,0x75,0x72,0x73,0x6F,0x72,
+	0x20,0x40,0x54,0x31,0x36,0x30,0x4D,0x61,0x72,0x6B,0x20,0x62,
+	0x6C,0x6F,0x63,0x6B,0x2E,0x16,0x3E,0x53,0x68,0x2B,0x46,0x33,
+	0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x75,0x74,0x20,0x74,0x72,
+	0x61,0x63,0x6B,0x2E,0x17,0x3E,0x53,0x68,0x2B,0x46,0x34,0x20,
+	0x40,0x54,0x31,0x36,0x30,0x43,0x6F,0x70,0x79,0x20,0x74,0x72,
+	0x61,0x63,0x6B,0x2E,0x18,0x3E,0x53,0x68,0x2B,0x46,0x35,0x20,
+	0x40,0x54,0x31,0x36,0x30,0x50,0x61,0x73,0x74,0x65,0x20,0x74,
+	0x72,0x61,0x63,0x6B,0x2E,0x1A,0x3E,0x43,0x74,0x72,0x6C,0x2B,
+	0x46,0x33,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x75,0x74,0x20,
+	0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x1B,0x3E,0x43,0x74,
+	0x72,0x6C,0x2B,0x46,0x34,0x20,0x40,0x54,0x31,0x36,0x30,0x43,
+	0x6F,0x70,0x79,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,
+	0x1C,0x3E,0x43,0x74,0x72,0x6C,0x2B,0x46,0x35,0x20,0x40,0x54,
+	0x31,0x36,0x30,0x50,0x61,0x73,0x74,0x65,0x20,0x70,0x61,0x74,
+	0x74,0x65,0x72,0x6E,0x2E,0x17,0x3E,0x41,0x6C,0x74,0x2B,0x46,
+	0x33,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x75,0x74,0x20,0x62,
+	0x6C,0x6F,0x63,0x6B,0x2E,0x18,0x3E,0x41,0x6C,0x74,0x2B,0x46,
+	0x34,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x6F,0x70,0x79,0x20,
+	0x62,0x6C,0x6F,0x63,0x6B,0x2E,0x19,0x3E,0x41,0x6C,0x74,0x2B,
 	0x46,0x35,0x20,0x40,0x54,0x31,0x36,0x30,0x50,0x61,0x73,0x74,
-	0x65,0x20,0x74,0x72,0x61,0x63,0x6B,0x2E,0x1A,0x3E,0x43,0x74,
+	0x65,0x20,0x62,0x6C,0x6F,0x63,0x6B,0x2E,0x20,0x3E,0x41,0x6C,
-	0x72,0x6C,0x2B,0x46,0x33,0x20,0x40,0x54,0x31,0x36,0x30,0x43,
+	0x74,0x2B,0x43,0x20,0x20,0x40,0x54,0x31,0x36,0x30,0x4D,0x61,
-	0x75,0x74,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x1B,
+	0x72,0x6B,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x74,
-	0x3E,0x43,0x74,0x72,0x6C,0x2B,0x46,0x34,0x20,0x40,0x54,0x31,
+	0x72,0x61,0x63,0x6B,0x2E,0x00,0x18,0x40,0x58,0x30,0x34,0x30,
-	0x36,0x30,0x43,0x6F,0x70,0x79,0x20,0x70,0x61,0x74,0x74,0x65,
+	0x40,0x43,0x30,0x30,0x31,0x4D,0x69,0x73,0x63,0x65,0x6C,0x6C,
-	0x72,0x6E,0x2E,0x1C,0x3E,0x43,0x74,0x72,0x6C,0x2B,0x46,0x35,
+	0x61,0x6E,0x65,0x6F,0x75,0x73,0x3A,0x0B,0x3E,0x40,0x58,0x30,
-	0x20,0x40,0x54,0x31,0x36,0x30,0x50,0x61,0x73,0x74,0x65,0x20,
+	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x1C,0x52,0x69,0x67,0x68,
-	0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x17,0x3E,0x41,0x6C,
+	0x74,0x20,0x63,0x74,0x72,0x6C,0x2E,0x20,0x20,0x40,0x54,0x31,
-	0x74,0x2B,0x46,0x33,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x75,
+	0x36,0x30,0x50,0x6C,0x61,0x79,0x20,0x73,0x6F,0x6E,0x67,0x2E,
-	0x74,0x20,0x62,0x6C,0x6F,0x63,0x6B,0x2E,0x18,0x3E,0x41,0x6C,
+	0x1D,0x3E,0x41,0x6C,0x74,0x20,0x47,0x72,0x20,0x20,0x20,0x20,
-	0x74,0x2B,0x46,0x34,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x6F,
+	0x40,0x54,0x31,0x36,0x30,0x50,0x6C,0x61,0x79,0x20,0x70,0x61,
-	0x70,0x79,0x20,0x62,0x6C,0x6F,0x63,0x6B,0x2E,0x19,0x3E,0x41,
+	0x74,0x74,0x65,0x72,0x6E,0x2E,0x22,0x3E,0x52,0x69,0x67,0x68,
-	0x6C,0x74,0x2B,0x46,0x35,0x20,0x40,0x54,0x31,0x36,0x30,0x50,
+	0x74,0x20,0x73,0x68,0x69,0x66,0x74,0x20,0x20,0x40,0x54,0x31,
-	0x61,0x73,0x74,0x65,0x20,0x62,0x6C,0x6F,0x63,0x6B,0x2E,0x20,
+	0x36,0x30,0x52,0x65,0x63,0x6F,0x72,0x64,0x20,0x70,0x61,0x74,
-	0x3E,0x41,0x6C,0x74,0x2B,0x43,0x20,0x20,0x40,0x54,0x31,0x36,
+	0x74,0x65,0x72,0x6E,0x2E,0x19,0x3E,0x53,0x70,0x61,0x63,0x65,
-	0x30,0x4D,0x61,0x72,0x6B,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,
+	0x20,0x20,0x20,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x74,0x6F,
-	0x74,0x20,0x74,0x72,0x61,0x63,0x6B,0x2E,0x00,0x18,0x40,0x58,
+	0x70,0x2F,0x45,0x64,0x69,0x74,0x2E,0x1B,0x3E,0x46,0x31,0x2E,
-	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x4D,0x69,0x73,0x63,
+	0x2E,0x46,0x37,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x65,0x6C,
-	0x65,0x6C,0x6C,0x61,0x6E,0x65,0x6F,0x75,0x73,0x3A,0x0B,0x3E,
+	0x65,0x63,0x74,0x20,0x6F,0x63,0x74,0x61,0x76,0x65,0x2E,0x27,
-	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x1C,0x52,
+	0x3E,0x4B,0x65,0x79,0x20,0x62,0x65,0x6C,0x6F,0x77,0x20,0x45,
-	0x69,0x67,0x68,0x74,0x20,0x63,0x74,0x72,0x6C,0x2E,0x20,0x20,
+	0x73,0x63,0x20,0x40,0x54,0x31,0x36,0x30,0x49,0x6E,0x63,0x72,
-	0x40,0x54,0x31,0x36,0x30,0x50,0x6C,0x61,0x79,0x20,0x73,0x6F,
+	0x65,0x61,0x73,0x65,0x20,0x63,0x75,0x72,0x73,0x6F,0x72,0x61,
-	0x6E,0x67,0x2E,0x1D,0x3E,0x41,0x6C,0x74,0x20,0x47,0x72,0x20,
+	0x64,0x64,0x2E,0x22,0x3E,0x53,0x68,0x2B,0x28,0x31,0x2F,0x32,
-	0x20,0x20,0x20,0x40,0x54,0x31,0x36,0x30,0x50,0x6C,0x61,0x79,
+	0x29,0x20,0x40,0x54,0x31,0x36,0x30,0x44,0x65,0x63,0x72,0x65,
-	0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x22,0x3E,0x52,
+	0x61,0x73,0x65,0x20,0x63,0x75,0x72,0x73,0x6F,0x72,0x61,0x64,
-	0x69,0x67,0x68,0x74,0x20,0x73,0x68,0x69,0x66,0x74,0x20,0x20,
+	0x64,0x2E,0x29,0x3E,0x43,0x61,0x70,0x73,0x4C,0x6F,0x63,0x6B,
-	0x40,0x54,0x31,0x36,0x30,0x52,0x65,0x63,0x6F,0x72,0x64,0x20,
+	0x20,0x6F,0x72,0x20,0x3C,0x3E,0x20,0x40,0x54,0x31,0x36,0x30,
-	0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x19,0x3E,0x53,0x70,
+	0x45,0x6E,0x74,0x65,0x72,0x20,0x4B,0x65,0x79,0x6F,0x66,0x66,
-	0x61,0x63,0x65,0x20,0x20,0x20,0x20,0x40,0x54,0x31,0x36,0x30,
+	0x2D,0x22,0x6E,0x6F,0x74,0x65,0x22,0x2E,0x25,0x3E,0x53,0x68,
-	0x53,0x74,0x6F,0x70,0x2F,0x45,0x64,0x69,0x74,0x2E,0x1B,0x3E,
+	0x2B,0x4C,0x65,0x66,0x74,0x20,0x40,0x54,0x31,0x36,0x30,0x49,
-	0x46,0x31,0x2E,0x2E,0x46,0x37,0x20,0x40,0x54,0x31,0x36,0x30,
+	0x6E,0x63,0x72,0x65,0x61,0x73,0x65,0x20,0x73,0x6F,0x6E,0x67,
-	0x53,0x65,0x6C,0x65,0x63,0x74,0x20,0x6F,0x63,0x74,0x61,0x76,
+	0x20,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x2E,0x26,0x3E,
-	0x65,0x2E,0x27,0x3E,0x4B,0x65,0x79,0x20,0x62,0x65,0x6C,0x6F,
+	0x53,0x68,0x2B,0x52,0x69,0x67,0x68,0x74,0x20,0x40,0x54,0x31,
-	0x77,0x20,0x45,0x73,0x63,0x20,0x40,0x54,0x31,0x36,0x30,0x49,
+	0x36,0x30,0x44,0x65,0x63,0x72,0x65,0x61,0x73,0x65,0x20,0x73,
-	0x6E,0x63,0x72,0x65,0x61,0x73,0x65,0x20,0x63,0x75,0x72,0x73,
-	0x6F,0x72,0x61,0x64,0x64,0x2E,0x22,0x3E,0x53,0x68,0x2B,0x28,
-	0x31,0x2F,0x32,0x29,0x20,0x40,0x54,0x31,0x36,0x30,0x44,0x65,
-	0x63,0x72,0x65,0x61,0x73,0x65,0x20,0x63,0x75,0x72,0x73,0x6F,
-	0x72,0x61,0x64,0x64,0x2E,0x29,0x3E,0x43,0x61,0x70,0x73,0x4C,
-	0x6F,0x63,0x6B,0x20,0x6F,0x72,0x20,0x3C,0x3E,0x20,0x40,0x54,
-	0x31,0x36,0x30,0x45,0x6E,0x74,0x65,0x72,0x20,0x4B,0x65,0x79,
-	0x6F,0x66,0x66,0x2D,0x22,0x6E,0x6F,0x74,0x65,0x22,0x2E,0x25,
-	0x3E,0x53,0x68,0x2B,0x4C,0x65,0x66,0x74,0x20,0x40,0x54,0x31,
-	0x36,0x30,0x49,0x6E,0x63,0x72,0x65,0x61,0x73,0x65,0x20,0x73,
 	0x6F,0x6E,0x67,0x20,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,
-	0x2E,0x26,0x3E,0x53,0x68,0x2B,0x52,0x69,0x67,0x68,0x74,0x20,
+	0x2E,0x28,0x3E,0x43,0x74,0x72,0x6C,0x2B,0x4C,0x65,0x66,0x74,
-	0x40,0x54,0x31,0x36,0x30,0x44,0x65,0x63,0x72,0x65,0x61,0x73,
+	0x20,0x40,0x54,0x31,0x36,0x30,0x49,0x6E,0x63,0x72,0x65,0x61,
-	0x65,0x20,0x73,0x6F,0x6E,0x67,0x20,0x70,0x6F,0x73,0x69,0x74,
+	0x73,0x65,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x6E,
-	0x69,0x6F,0x6E,0x2E,0x28,0x3E,0x43,0x74,0x72,0x6C,0x2B,0x4C,
+	0x75,0x6D,0x62,0x65,0x72,0x2E,0x29,0x3E,0x43,0x74,0x72,0x6C,
-	0x65,0x66,0x74,0x20,0x40,0x54,0x31,0x36,0x30,0x49,0x6E,0x63,
+	0x2B,0x52,0x69,0x67,0x68,0x74,0x20,0x40,0x54,0x31,0x36,0x30,
-	0x72,0x65,0x61,0x73,0x65,0x20,0x70,0x61,0x74,0x74,0x65,0x72,
+	0x44,0x65,0x63,0x72,0x65,0x61,0x73,0x65,0x20,0x70,0x61,0x74,
-	0x6E,0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x2E,0x29,0x3E,0x43,
+	0x74,0x65,0x72,0x6E,0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x2E,
-	0x74,0x72,0x6C,0x2B,0x52,0x69,0x67,0x68,0x74,0x20,0x40,0x54,
+	0x00,0x2C,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
-	0x31,0x36,0x30,0x44,0x65,0x63,0x72,0x65,0x61,0x73,0x65,0x20,
+	0x4D,0x69,0x73,0x63,0x65,0x6C,0x6C,0x61,0x6E,0x65,0x6F,0x75,
-	0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x6E,0x75,0x6D,0x62,
+	0x73,0x20,0x28,0x6F,0x6E,0x20,0x61,0x20,0x4D,0x61,0x63,0x20,
-	0x65,0x72,0x2E,0x00,0x2C,0x40,0x58,0x30,0x34,0x30,0x40,0x43,
+	0x6B,0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x29,0x3A,0x0B,0x3E,
-	0x30,0x30,0x31,0x4D,0x69,0x73,0x63,0x65,0x6C,0x6C,0x61,0x6E,
+	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x1E,0x52,
-	0x65,0x6F,0x75,0x73,0x20,0x28,0x6F,0x6E,0x20,0x61,0x20,0x4D,
+	0x69,0x67,0x68,0x74,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,
-	0x61,0x63,0x20,0x6B,0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x29,
+	0x20,0x20,0x40,0x54,0x32,0x34,0x30,0x50,0x6C,0x61,0x79,0x20,
-	0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,
+	0x73,0x6F,0x6E,0x67,0x2E,0x32,0x3E,0x52,0x69,0x67,0x68,0x74,
-	0x32,0x1E,0x52,0x69,0x67,0x68,0x74,0x20,0x63,0x6F,0x6D,0x6D,
+	0x20,0x61,0x6C,0x74,0x20,0x28,0x6F,0x72,0x20,0x6C,0x65,0x66,
-	0x61,0x6E,0x64,0x20,0x20,0x40,0x54,0x32,0x34,0x30,0x50,0x6C,
+	0x74,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x29,0x20,0x20,
-	0x61,0x79,0x20,0x73,0x6F,0x6E,0x67,0x2E,0x32,0x3E,0x52,0x69,
+	0x20,0x20,0x40,0x54,0x32,0x34,0x30,0x50,0x6C,0x61,0x79,0x20,
-	0x67,0x68,0x74,0x20,0x61,0x6C,0x74,0x20,0x28,0x6F,0x72,0x20,
+	0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x22,0x3E,0x52,0x69,
-	0x6C,0x65,0x66,0x74,0x20,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,
+	0x67,0x68,0x74,0x20,0x73,0x68,0x69,0x66,0x74,0x20,0x20,0x40,
-	0x29,0x20,0x20,0x20,0x20,0x40,0x54,0x32,0x34,0x30,0x50,0x6C,
+	0x54,0x32,0x34,0x30,0x52,0x65,0x63,0x6F,0x72,0x64,0x20,0x70,
-	0x61,0x79,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x22,
+	0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x00,0x1B,0x40,0x58,0x30,
-	0x3E,0x52,0x69,0x67,0x68,0x74,0x20,0x73,0x68,0x69,0x66,0x74,
+	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x57,0x69,0x6E,0x64,0x6F,
-	0x20,0x20,0x40,0x54,0x32,0x34,0x30,0x52,0x65,0x63,0x6F,0x72,
+	0x77,0x20,0x73,0x77,0x69,0x74,0x63,0x68,0x69,0x6E,0x67,0x3A,
-	0x64,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x00,0x1B,
+	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x57,0x69,
+	0x05,0x43,0x74,0x72,0x6C,0x2B,0x16,0x3E,0x41,0x20,0x40,0x54,
-	0x6E,0x64,0x6F,0x77,0x20,0x73,0x77,0x69,0x74,0x63,0x68,0x69,
+	0x31,0x36,0x30,0x41,0x64,0x76,0x61,0x6E,0x63,0x65,0x64,0x20,
-	0x6E,0x67,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
+	0x65,0x64,0x69,0x74,0x2E,0x0E,0x3E,0x42,0x20,0x40,0x54,0x31,
-	0x30,0x30,0x32,0x05,0x43,0x74,0x72,0x6C,0x2B,0x16,0x3E,0x41,
+	0x36,0x30,0x41,0x62,0x6F,0x75,0x74,0x2E,0x16,0x3E,0x43,0x20,
-	0x20,0x40,0x54,0x31,0x36,0x30,0x41,0x64,0x76,0x61,0x6E,0x63,
+	0x40,0x54,0x31,0x36,0x30,0x43,0x6F,0x6E,0x66,0x69,0x67,0x75,
-	0x65,0x64,0x20,0x65,0x64,0x69,0x74,0x2E,0x0E,0x3E,0x42,0x20,
+	0x72,0x61,0x74,0x69,0x6F,0x6E,0x2E,0x18,0x3E,0x44,0x20,0x40,
-	0x40,0x54,0x31,0x36,0x30,0x41,0x62,0x6F,0x75,0x74,0x2E,0x16,
+	0x54,0x31,0x36,0x30,0x44,0x69,0x73,0x6B,0x20,0x6F,0x70,0x65,
-	0x3E,0x43,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x6F,0x6E,0x66,
+	0x72,0x61,0x74,0x69,0x6F,0x6E,0x73,0x2E,0x20,0x3E,0x45,0x20,
-	0x69,0x67,0x75,0x72,0x61,0x74,0x69,0x6F,0x6E,0x2E,0x18,0x3E,
+	0x40,0x54,0x31,0x36,0x30,0x53,0x61,0x6D,0x70,0x6C,0x65,0x20,
-	0x44,0x20,0x40,0x54,0x31,0x36,0x30,0x44,0x69,0x73,0x6B,0x20,
+	0x65,0x64,0x69,0x74,0x6F,0x72,0x20,0x65,0x78,0x74,0x65,0x6E,
-	0x6F,0x70,0x65,0x72,0x61,0x74,0x69,0x6F,0x6E,0x73,0x2E,0x20,
+	0x73,0x69,0x6F,0x6E,0x2E,0x0D,0x3E,0x48,0x20,0x40,0x54,0x31,
-	0x3E,0x45,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x61,0x6D,0x70,
+	0x36,0x30,0x48,0x65,0x6C,0x70,0x2E,0x1A,0x3E,0x49,0x20,0x40,
-	0x6C,0x65,0x20,0x65,0x64,0x69,0x74,0x6F,0x72,0x20,0x65,0x78,
+	0x54,0x31,0x36,0x30,0x49,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,
-	0x74,0x65,0x6E,0x73,0x69,0x6F,0x6E,0x2E,0x0D,0x3E,0x48,0x20,
+	0x6E,0x74,0x20,0x65,0x64,0x69,0x74,0x6F,0x72,0x2E,0x2B,0x3E,
-	0x40,0x54,0x31,0x36,0x30,0x48,0x65,0x6C,0x70,0x2E,0x1A,0x3E,
+	0x4D,0x20,0x40,0x54,0x31,0x36,0x30,0x49,0x6E,0x73,0x74,0x72,
-	0x49,0x20,0x40,0x54,0x31,0x36,0x30,0x49,0x6E,0x73,0x74,0x72,
 	0x75,0x6D,0x65,0x6E,0x74,0x20,0x65,0x64,0x69,0x74,0x6F,0x72,
-	0x2E,0x2B,0x3E,0x4D,0x20,0x40,0x54,0x31,0x36,0x30,0x49,0x6E,
+	0x20,0x65,0x78,0x74,0x65,0x6E,0x73,0x69,0x6F,0x6E,0x2E,0x20,
-	0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x65,0x64,0x69,
+	0x28,0x4D,0x49,0x44,0x49,0x29,0x10,0x3E,0x4E,0x20,0x40,0x54,
-	0x74,0x6F,0x72,0x20,0x65,0x78,0x74,0x65,0x6E,0x73,0x69,0x6F,
+	0x31,0x36,0x30,0x4E,0x69,0x62,0x62,0x6C,0x65,0x73,0x2E,0x10,
-	0x6E,0x2E,0x20,0x28,0x4D,0x49,0x44,0x49,0x29,0x10,0x3E,0x4E,
+	0x3E,0x50,0x20,0x40,0x54,0x31,0x36,0x30,0x50,0x61,0x74,0x74,
-	0x20,0x40,0x54,0x31,0x36,0x30,0x4E,0x69,0x62,0x62,0x6C,0x65,
+	0x65,0x72,0x6E,0x2E,0x0D,0x3E,0x52,0x20,0x40,0x54,0x31,0x36,
-	0x73,0x2E,0x10,0x3E,0x50,0x20,0x40,0x54,0x31,0x36,0x30,0x50,
+	0x30,0x54,0x72,0x69,0x6D,0x2E,0x16,0x3E,0x53,0x20,0x40,0x54,
-	0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x0D,0x3E,0x52,0x20,0x40,
+	0x31,0x36,0x30,0x53,0x61,0x6D,0x70,0x6C,0x65,0x20,0x65,0x64,
-	0x54,0x31,0x36,0x30,0x54,0x72,0x69,0x6D,0x2E,0x16,0x3E,0x53,
+	0x69,0x74,0x6F,0x72,0x2E,0x12,0x3E,0x54,0x20,0x40,0x54,0x31,
-	0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x61,0x6D,0x70,0x6C,0x65,
+	0x36,0x30,0x54,0x72,0x61,0x6E,0x73,0x70,0x6F,0x73,0x65,0x2E,
-	0x20,0x65,0x64,0x69,0x74,0x6F,0x72,0x2E,0x12,0x3E,0x54,0x20,
+	0x23,0x3E,0x58,0x20,0x40,0x54,0x31,0x36,0x30,0x4D,0x61,0x69,
-	0x40,0x54,0x31,0x36,0x30,0x54,0x72,0x61,0x6E,0x73,0x70,0x6F,
+	0x6E,0x20,0x73,0x63,0x72,0x65,0x65,0x6E,0x2E,0x20,0x28,0x61,
-	0x73,0x65,0x2E,0x23,0x3E,0x58,0x20,0x40,0x54,0x31,0x36,0x30,
+	0x6C,0x6D,0x6F,0x73,0x74,0x20,0x61,0x6C,0x74,0x2B,0x58,0x29,
-	0x4D,0x61,0x69,0x6E,0x20,0x73,0x63,0x72,0x65,0x65,0x6E,0x2E,
+	0x27,0x3E,0x5A,0x20,0x40,0x54,0x31,0x36,0x30,0x46,0x75,0x6C,
-	0x20,0x28,0x61,0x6C,0x6D,0x6F,0x73,0x74,0x20,0x61,0x6C,0x74,
+	0x6C,0x20,0x73,0x63,0x72,0x65,0x65,0x6E,0x20,0x65,0x64,0x69,
-	0x2B,0x58,0x29,0x27,0x3E,0x5A,0x20,0x40,0x54,0x31,0x36,0x30,
+	0x74,0x2E,0x20,0x28,0x5A,0x20,0x66,0x6F,0x72,0x20,0x73,0x69,
-	0x46,0x75,0x6C,0x6C,0x20,0x73,0x63,0x72,0x65,0x65,0x6E,0x20,
+	0x5A,0x65,0x3F,0x29,0x19,0x3E,0x31,0x20,0x40,0x54,0x31,0x36,
-	0x65,0x64,0x69,0x74,0x2E,0x20,0x28,0x5A,0x20,0x66,0x6F,0x72,
+	0x30,0x43,0x6F,0x6E,0x66,0x69,0x67,0x75,0x72,0x61,0x74,0x69,
-	0x20,0x73,0x69,0x5A,0x65,0x3F,0x29,0x19,0x3E,0x31,0x20,0x40,
+	0x6F,0x6E,0x20,0x23,0x31,0x2E,0x19,0x3E,0x32,0x20,0x40,0x54,
-	0x54,0x31,0x36,0x30,0x43,0x6F,0x6E,0x66,0x69,0x67,0x75,0x72,
+	0x31,0x36,0x30,0x43,0x6F,0x6E,0x66,0x69,0x67,0x75,0x72,0x61,
-	0x61,0x74,0x69,0x6F,0x6E,0x20,0x23,0x31,0x2E,0x19,0x3E,0x32,
+	0x74,0x69,0x6F,0x6E,0x20,0x23,0x32,0x2E,0x19,0x3E,0x33,0x20,
-	0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x6F,0x6E,0x66,0x69,0x67,
+	0x40,0x54,0x31,0x36,0x30,0x43,0x6F,0x6E,0x66,0x69,0x67,0x75,
-	0x75,0x72,0x61,0x74,0x69,0x6F,0x6E,0x20,0x23,0x32,0x2E,0x19,
+	0x72,0x61,0x74,0x69,0x6F,0x6E,0x20,0x23,0x33,0x2E,0x19,0x3E,
-	0x3E,0x33,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x6F,0x6E,0x66,
+	0x34,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x6F,0x6E,0x66,0x69,
-	0x69,0x67,0x75,0x72,0x61,0x74,0x69,0x6F,0x6E,0x20,0x23,0x33,
+	0x67,0x75,0x72,0x61,0x74,0x69,0x6F,0x6E,0x20,0x23,0x34,0x2E,
-	0x2E,0x19,0x3E,0x34,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x6F,
+	0x00,0x2D,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
-	0x6E,0x66,0x69,0x67,0x75,0x72,0x61,0x74,0x69,0x6F,0x6E,0x20,
+	0x49,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x73,
-	0x23,0x34,0x2E,0x00,0x2D,0x40,0x58,0x30,0x34,0x30,0x40,0x43,
+	0x65,0x6C,0x65,0x63,0x74,0x20,0x28,0x4E,0x75,0x6D,0x65,0x72,
-	0x30,0x30,0x31,0x49,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,
+	0x69,0x63,0x20,0x6B,0x65,0x79,0x70,0x61,0x64,0x29,0x3A,0x0B,
-	0x74,0x20,0x73,0x65,0x6C,0x65,0x63,0x74,0x20,0x28,0x4E,0x75,
+	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x28,
-	0x6D,0x65,0x72,0x69,0x63,0x20,0x6B,0x65,0x79,0x70,0x61,0x64,
+	0x54,0x6F,0x70,0x20,0x34,0x20,0x6B,0x65,0x79,0x73,0x20,0x40,
-	0x29,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
-	0x30,0x32,0x28,0x54,0x6F,0x70,0x20,0x34,0x20,0x6B,0x65,0x79,
-	0x73,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x65,0x6C,0x65,0x63,
-	0x74,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,
-	0x20,0x62,0x6C,0x6F,0x63,0x6B,0x2E,0x32,0x3E,0x27,0x2B,0x27,
-	0x20,0x2B,0x54,0x6F,0x70,0x20,0x34,0x20,0x6B,0x65,0x79,0x73,
-	0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x65,0x6C,0x65,0x63,0x74,
-	0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,
-	0x62,0x6C,0x6F,0x63,0x6B,0x20,0x2B,0x20,0x34,0x2E,0x23,0x3E,
-	0x45,0x6E,0x74,0x65,0x72,0x20,0x40,0x54,0x31,0x36,0x30,0x53,
-	0x65,0x6C,0x65,0x63,0x74,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,
-	0x6D,0x65,0x6E,0x74,0x20,0x62,0x61,0x6E,0x6B,0x2E,0x1D,0x3E,
-	0x30,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x65,0x6C,0x65,0x63,
-	0x74,0x20,0x6E,0x6F,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,
-	0x65,0x6E,0x74,0x2E,0x26,0x3E,0x31,0x2E,0x2E,0x38,0x20,0x40,
 	0x54,0x31,0x36,0x30,0x53,0x65,0x6C,0x65,0x63,0x74,0x20,0x69,
-	0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x69,0x6E,
+	0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x62,0x6C,
-	0x20,0x62,0x6C,0x6F,0x63,0x6B,0x2E,0x19,0x3E,0x2C,0x20,0x40,
+	0x6F,0x63,0x6B,0x2E,0x32,0x3E,0x27,0x2B,0x27,0x20,0x2B,0x54,
-	0x54,0x31,0x36,0x30,0x43,0x6C,0x65,0x61,0x72,0x20,0x69,0x6E,
+	0x6F,0x70,0x20,0x34,0x20,0x6B,0x65,0x79,0x73,0x20,0x40,0x54,
-	0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x2E,0x18,0x3E,0x53,
+	0x31,0x36,0x30,0x53,0x65,0x6C,0x65,0x63,0x74,0x20,0x69,0x6E,
-	0x68,0x2B,0x2C,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x6C,0x65,
+	0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x62,0x6C,0x6F,
-	0x61,0x72,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x2E,0x27,0x3E,
+	0x63,0x6B,0x20,0x2B,0x20,0x34,0x2E,0x23,0x3E,0x45,0x6E,0x74,
-	0x53,0x68,0x2B,0x55,0x70,0x20,0x40,0x54,0x31,0x36,0x30,0x53,
+	0x65,0x72,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x65,0x6C,0x65,
-	0x65,0x6C,0x65,0x63,0x74,0x20,0x70,0x72,0x65,0x76,0x69,0x6F,
+	0x63,0x74,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,
-	0x75,0x73,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,
+	0x74,0x20,0x62,0x61,0x6E,0x6B,0x2E,0x1D,0x3E,0x30,0x20,0x40,
-	0x74,0x2E,0x25,0x3E,0x53,0x68,0x2B,0x44,0x6F,0x77,0x6E,0x20,
+	0x54,0x31,0x36,0x30,0x53,0x65,0x6C,0x65,0x63,0x74,0x20,0x6E,
-	0x40,0x54,0x31,0x36,0x30,0x53,0x65,0x6C,0x65,0x63,0x74,0x20,
+	0x6F,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,
-	0x6E,0x65,0x78,0x74,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,
+	0x2E,0x26,0x3E,0x31,0x2E,0x2E,0x38,0x20,0x40,0x54,0x31,0x36,
-	0x65,0x6E,0x74,0x2E,0x00,0x1F,0x40,0x58,0x30,0x34,0x30,0x40,
+	0x30,0x53,0x65,0x6C,0x65,0x63,0x74,0x20,0x69,0x6E,0x73,0x74,
-	0x43,0x30,0x30,0x31,0x43,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x2F,
+	0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x69,0x6E,0x20,0x62,0x6C,
-	0x56,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x6D,0x61,0x63,0x72,0x6F,
+	0x6F,0x63,0x6B,0x2E,0x19,0x3E,0x2C,0x20,0x40,0x54,0x31,0x36,
-	0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,
+	0x30,0x43,0x6C,0x65,0x61,0x72,0x20,0x69,0x6E,0x73,0x74,0x72,
-	0x32,0x2D,0x41,0x6C,0x74,0x2B,0x31,0x2E,0x2E,0x30,0x20,0x40,
+	0x75,0x6D,0x65,0x6E,0x74,0x2E,0x18,0x3E,0x53,0x68,0x2B,0x2C,
-	0x54,0x31,0x36,0x30,0x57,0x72,0x69,0x74,0x65,0x20,0x63,0x6F,
+	0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x6C,0x65,0x61,0x72,0x20,
-	0x6D,0x6D,0x61,0x6E,0x64,0x2F,0x76,0x6F,0x6C,0x75,0x6D,0x65,
+	0x73,0x61,0x6D,0x70,0x6C,0x65,0x2E,0x27,0x3E,0x53,0x68,0x2B,
-	0x20,0x61,0x74,0x20,0x63,0x75,0x72,0x73,0x6F,0x72,0x2E,0x30,
+	0x55,0x70,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x65,0x6C,0x65,
-	0x3E,0x53,0x68,0x2B,0x41,0x6C,0x74,0x2B,0x31,0x2E,0x2E,0x30,
+	0x63,0x74,0x20,0x70,0x72,0x65,0x76,0x69,0x6F,0x75,0x73,0x20,
-	0x20,0x40,0x54,0x31,0x36,0x30,0x52,0x65,0x61,0x64,0x20,0x63,
+	0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x2E,0x25,
-	0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x2F,0x76,0x6F,0x6C,0x75,0x6D,
+	0x3E,0x53,0x68,0x2B,0x44,0x6F,0x77,0x6E,0x20,0x40,0x54,0x31,
-	0x65,0x20,0x61,0x74,0x20,0x63,0x75,0x72,0x73,0x6F,0x72,0x2E,
+	0x36,0x30,0x53,0x65,0x6C,0x65,0x63,0x74,0x20,0x6E,0x65,0x78,
-	0x00,0x1C,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
+	0x74,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,
-	0x53,0x63,0x61,0x6C,0x65,0x2D,0x66,0x61,0x64,0x65,0x20,0x76,
+	0x2E,0x00,0x1F,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
-	0x6F,0x6C,0x75,0x6D,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,
+	0x31,0x43,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x2F,0x56,0x6F,0x6C,
-	0x30,0x40,0x43,0x30,0x30,0x32,0x25,0x53,0x68,0x2B,0x56,0x20,
+	0x75,0x6D,0x65,0x20,0x6D,0x61,0x63,0x72,0x6F,0x3A,0x0B,0x3E,
-	0x40,0x54,0x31,0x36,0x30,0x53,0x63,0x61,0x6C,0x65,0x2D,0x66,
+	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x2D,0x41,
-	0x61,0x64,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x69,
+	0x6C,0x74,0x2B,0x31,0x2E,0x2E,0x30,0x20,0x40,0x54,0x31,0x36,
-	0x6E,0x20,0x74,0x72,0x61,0x63,0x6B,0x2E,0x2A,0x3E,0x43,0x74,
+	0x30,0x57,0x72,0x69,0x74,0x65,0x20,0x63,0x6F,0x6D,0x6D,0x61,
-	0x72,0x6C,0x2B,0x56,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x63,
+	0x6E,0x64,0x2F,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x61,0x74,
-	0x61,0x6C,0x65,0x2D,0x66,0x61,0x64,0x65,0x20,0x76,0x6F,0x6C,
+	0x20,0x63,0x75,0x72,0x73,0x6F,0x72,0x2E,0x30,0x3E,0x53,0x68,
-	0x75,0x6D,0x65,0x20,0x69,0x6E,0x20,0x70,0x61,0x74,0x74,0x65,
+	0x2B,0x41,0x6C,0x74,0x2B,0x31,0x2E,0x2E,0x30,0x20,0x40,0x54,
-	0x72,0x6E,0x2E,0x27,0x3E,0x41,0x6C,0x74,0x2B,0x56,0x20,0x40,
+	0x31,0x36,0x30,0x52,0x65,0x61,0x64,0x20,0x63,0x6F,0x6D,0x6D,
-	0x54,0x31,0x36,0x30,0x53,0x63,0x61,0x6C,0x65,0x2D,0x66,0x61,
+	0x61,0x6E,0x64,0x2F,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x61,
-	0x64,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x69,0x6E,
+	0x74,0x20,0x63,0x75,0x72,0x73,0x6F,0x72,0x2E,0x00,0x1C,0x40,
-	0x20,0x62,0x6C,0x6F,0x63,0x6B,0x2E,0x00,0x14,0x40,0x58,0x30,
+	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x63,0x61,
-	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x54,0x72,0x61,0x6E,0x73,
+	0x6C,0x65,0x2D,0x66,0x61,0x64,0x65,0x20,0x76,0x6F,0x6C,0x75,
-	0x70,0x6F,0x73,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,
+	0x6D,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
-	0x40,0x43,0x30,0x30,0x32,0x36,0x53,0x68,0x2B,0x46,0x37,0x20,
+	0x30,0x30,0x32,0x25,0x53,0x68,0x2B,0x56,0x20,0x40,0x54,0x31,
-	0x40,0x54,0x31,0x36,0x30,0x54,0x72,0x61,0x6E,0x73,0x70,0x6F,
+	0x36,0x30,0x53,0x63,0x61,0x6C,0x65,0x2D,0x66,0x61,0x64,0x65,
-	0x73,0x65,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x69,
+	0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x69,0x6E,0x20,0x74,
-	0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x69,0x6E,
+	0x72,0x61,0x63,0x6B,0x2E,0x2A,0x3E,0x43,0x74,0x72,0x6C,0x2B,
-	0x20,0x74,0x72,0x61,0x63,0x6B,0x20,0x64,0x6F,0x77,0x6E,0x2E,
+	0x56,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x63,0x61,0x6C,0x65,
-	0x35,0x3E,0x53,0x68,0x2B,0x46,0x38,0x20,0x40,0x54,0x31,0x36,
+	0x2D,0x66,0x61,0x64,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,
-	0x30,0x54,0x72,0x61,0x6E,0x73,0x70,0x6F,0x73,0x65,0x20,0x63,
+	0x20,0x69,0x6E,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,
-	0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x69,0x6E,0x73,0x74,0x72,
+	0x27,0x3E,0x41,0x6C,0x74,0x2B,0x56,0x20,0x40,0x54,0x31,0x36,
-	0x75,0x6D,0x65,0x6E,0x74,0x20,0x69,0x6E,0x20,0x74,0x72,0x61,
+	0x30,0x53,0x63,0x61,0x6C,0x65,0x2D,0x66,0x61,0x64,0x65,0x20,
-	0x63,0x6B,0x20,0x75,0x70,0x2E,0x3B,0x3E,0x43,0x74,0x72,0x6C,
+	0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x69,0x6E,0x20,0x62,0x6C,
-	0x2B,0x46,0x37,0x20,0x40,0x54,0x31,0x36,0x30,0x54,0x72,0x61,
+	0x6F,0x63,0x6B,0x2E,0x00,0x14,0x40,0x58,0x30,0x34,0x30,0x40,
-	0x6E,0x73,0x70,0x6F,0x73,0x65,0x20,0x63,0x75,0x72,0x72,0x65,
+	0x43,0x30,0x30,0x31,0x54,0x72,0x61,0x6E,0x73,0x70,0x6F,0x73,
-	0x6E,0x74,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,
+	0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
-	0x74,0x20,0x69,0x6E,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,
+	0x30,0x32,0x36,0x53,0x68,0x2B,0x46,0x37,0x20,0x40,0x54,0x31,
-	0x20,0x64,0x6F,0x77,0x6E,0x2E,0x39,0x3E,0x43,0x74,0x72,0x6C,
+	0x36,0x30,0x54,0x72,0x61,0x6E,0x73,0x70,0x6F,0x73,0x65,0x20,
-	0x2B,0x46,0x38,0x20,0x40,0x54,0x31,0x36,0x30,0x54,0x72,0x61,
+	0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x69,0x6E,0x73,0x74,
-	0x6E,0x73,0x70,0x6F,0x73,0x65,0x20,0x63,0x75,0x72,0x72,0x65,
+	0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x69,0x6E,0x20,0x74,0x72,
-	0x6E,0x74,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,
+	0x61,0x63,0x6B,0x20,0x64,0x6F,0x77,0x6E,0x2E,0x35,0x3E,0x53,
-	0x74,0x20,0x69,0x6E,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,
+	0x68,0x2B,0x46,0x38,0x20,0x40,0x54,0x31,0x36,0x30,0x54,0x72,
-	0x20,0x75,0x70,0x2E,0x38,0x3E,0x41,0x6C,0x74,0x2B,0x46,0x37,
+	0x61,0x6E,0x73,0x70,0x6F,0x73,0x65,0x20,0x63,0x75,0x72,0x72,
+	0x65,0x6E,0x74,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,
+	0x6E,0x74,0x20,0x69,0x6E,0x20,0x74,0x72,0x61,0x63,0x6B,0x20,
+	0x75,0x70,0x2E,0x3B,0x3E,0x43,0x74,0x72,0x6C,0x2B,0x46,0x37,
 	0x20,0x40,0x54,0x31,0x36,0x30,0x54,0x72,0x61,0x6E,0x73,0x70,
 	0x6F,0x73,0x65,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,
 	0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x69,
-	0x6E,0x20,0x62,0x6C,0x6F,0x63,0x6B,0x20,0x64,0x6F,0x77,0x6E,
+	0x6E,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x64,0x6F,
-	0x2E,0x36,0x3E,0x41,0x6C,0x74,0x2B,0x46,0x38,0x20,0x40,0x54,
+	0x77,0x6E,0x2E,0x39,0x3E,0x43,0x74,0x72,0x6C,0x2B,0x46,0x38,
+	0x20,0x40,0x54,0x31,0x36,0x30,0x54,0x72,0x61,0x6E,0x73,0x70,
+	0x6F,0x73,0x65,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,
+	0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x69,
+	0x6E,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x75,0x70,
+	0x2E,0x38,0x3E,0x41,0x6C,0x74,0x2B,0x46,0x37,0x20,0x40,0x54,
 	0x31,0x36,0x30,0x54,0x72,0x61,0x6E,0x73,0x70,0x6F,0x73,0x65,
 	0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x69,0x6E,0x73,
 	0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x69,0x6E,0x20,0x62,
-	0x6C,0x6F,0x63,0x6B,0x20,0x75,0x70,0x2E,0x34,0x3E,0x53,0x68,
+	0x6C,0x6F,0x63,0x6B,0x20,0x64,0x6F,0x77,0x6E,0x2E,0x36,0x3E,
-	0x2B,0x46,0x31,0x20,0x40,0x54,0x31,0x36,0x30,0x54,0x72,0x61,
+	0x41,0x6C,0x74,0x2B,0x46,0x38,0x20,0x40,0x54,0x31,0x36,0x30,
-	0x6E,0x73,0x70,0x6F,0x73,0x65,0x20,0x61,0x6C,0x6C,0x20,0x69,
+	0x54,0x72,0x61,0x6E,0x73,0x70,0x6F,0x73,0x65,0x20,0x63,0x75,
-	0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x73,0x20,0x69,
+	0x72,0x72,0x65,0x6E,0x74,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,
-	0x6E,0x20,0x74,0x72,0x61,0x63,0x6B,0x20,0x64,0x6F,0x77,0x6E,
+	0x6D,0x65,0x6E,0x74,0x20,0x69,0x6E,0x20,0x62,0x6C,0x6F,0x63,
-	0x2E,0x32,0x3E,0x53,0x68,0x2B,0x46,0x32,0x20,0x40,0x54,0x31,
+	0x6B,0x20,0x75,0x70,0x2E,0x34,0x3E,0x53,0x68,0x2B,0x46,0x31,
-	0x36,0x30,0x54,0x72,0x61,0x6E,0x73,0x70,0x6F,0x73,0x65,0x20,
+	0x20,0x40,0x54,0x31,0x36,0x30,0x54,0x72,0x61,0x6E,0x73,0x70,
-	0x61,0x6C,0x6C,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,
+	0x6F,0x73,0x65,0x20,0x61,0x6C,0x6C,0x20,0x69,0x6E,0x73,0x74,
-	0x6E,0x74,0x73,0x20,0x69,0x6E,0x20,0x74,0x72,0x61,0x63,0x6B,
+	0x72,0x75,0x6D,0x65,0x6E,0x74,0x73,0x20,0x69,0x6E,0x20,0x74,
-	0x20,0x75,0x70,0x2E,0x38,0x3E,0x43,0x74,0x72,0x6C,0x2B,0x46,
+	0x72,0x61,0x63,0x6B,0x20,0x64,0x6F,0x77,0x6E,0x2E,0x32,0x3E,
-	0x31,0x20,0x40,0x54,0x31,0x36,0x30,0x54,0x72,0x61,0x6E,0x73,
+	0x53,0x68,0x2B,0x46,0x32,0x20,0x40,0x54,0x31,0x36,0x30,0x54,
-	0x70,0x6F,0x73,0x65,0x20,0x61,0x6C,0x6C,0x20,0x69,0x6E,0x73,
+	0x72,0x61,0x6E,0x73,0x70,0x6F,0x73,0x65,0x20,0x61,0x6C,0x6C,
-	0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x73,0x20,0x69,0x6E,0x20,
+	0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x73,
-	0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x64,0x6F,0x77,0x6E,
+	0x20,0x69,0x6E,0x20,0x74,0x72,0x61,0x63,0x6B,0x20,0x75,0x70,
-	0x2E,0x36,0x3E,0x43,0x74,0x72,0x6C,0x2B,0x46,0x32,0x20,0x40,
+	0x2E,0x38,0x3E,0x43,0x74,0x72,0x6C,0x2B,0x46,0x31,0x20,0x40,
 	0x54,0x31,0x36,0x30,0x54,0x72,0x61,0x6E,0x73,0x70,0x6F,0x73,
 	0x65,0x20,0x61,0x6C,0x6C,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,
 	0x6D,0x65,0x6E,0x74,0x73,0x20,0x69,0x6E,0x20,0x70,0x61,0x74,
-	0x74,0x65,0x72,0x6E,0x20,0x75,0x70,0x2E,0x35,0x3E,0x41,0x6C,
+	0x74,0x65,0x72,0x6E,0x20,0x64,0x6F,0x77,0x6E,0x2E,0x36,0x3E,
-	0x74,0x2B,0x46,0x31,0x20,0x40,0x54,0x31,0x36,0x30,0x54,0x72,
+	0x43,0x74,0x72,0x6C,0x2B,0x46,0x32,0x20,0x40,0x54,0x31,0x36,
-	0x61,0x6E,0x73,0x70,0x6F,0x73,0x65,0x20,0x61,0x6C,0x6C,0x20,
+	0x30,0x54,0x72,0x61,0x6E,0x73,0x70,0x6F,0x73,0x65,0x20,0x61,
-	0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x73,0x20,
+	0x6C,0x6C,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,
-	0x69,0x6E,0x20,0x62,0x6C,0x6F,0x63,0x6B,0x20,0x64,0x6F,0x77,
+	0x74,0x73,0x20,0x69,0x6E,0x20,0x70,0x61,0x74,0x74,0x65,0x72,
-	0x6E,0x2E,0x33,0x3E,0x41,0x6C,0x74,0x2B,0x46,0x32,0x20,0x40,
+	0x6E,0x20,0x75,0x70,0x2E,0x35,0x3E,0x41,0x6C,0x74,0x2B,0x46,
-	0x54,0x31,0x36,0x30,0x54,0x72,0x61,0x6E,0x73,0x70,0x6F,0x73,
+	0x31,0x20,0x40,0x54,0x31,0x36,0x30,0x54,0x72,0x61,0x6E,0x73,
-	0x65,0x20,0x61,0x6C,0x6C,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,
+	0x70,0x6F,0x73,0x65,0x20,0x61,0x6C,0x6C,0x20,0x69,0x6E,0x73,
-	0x6D,0x65,0x6E,0x74,0x73,0x20,0x69,0x6E,0x20,0x62,0x6C,0x6F,
+	0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x73,0x20,0x69,0x6E,0x20,
-	0x63,0x6B,0x20,0x75,0x70,0x2E,0x01,0x3E,0x18,0x40,0x58,0x30,
+	0x62,0x6C,0x6F,0x63,0x6B,0x20,0x64,0x6F,0x77,0x6E,0x2E,0x33,
-	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x61,0x6D,0x70,0x6C,
+	0x3E,0x41,0x6C,0x74,0x2B,0x46,0x32,0x20,0x40,0x54,0x31,0x36,
-	0x65,0x20,0x65,0x64,0x69,0x74,0x6F,0x72,0x3A,0x0B,0x3E,0x40,
+	0x30,0x54,0x72,0x61,0x6E,0x73,0x70,0x6F,0x73,0x65,0x20,0x61,
-	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x1A,0x41,0x6C,
+	0x6C,0x6C,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,
-	0x74,0x2F,0x43,0x74,0x72,0x6C,0x2B,0x41,0x20,0x40,0x54,0x31,
+	0x74,0x73,0x20,0x69,0x6E,0x20,0x62,0x6C,0x6F,0x63,0x6B,0x20,
-	0x36,0x30,0x52,0x61,0x6E,0x67,0x65,0x20,0x61,0x6C,0x6C,0x2E,
+	0x75,0x70,0x2E,0x01,0x3E,0x18,0x40,0x58,0x30,0x34,0x30,0x40,
-	0x17,0x3E,0x41,0x6C,0x74,0x2B,0x53,0x20,0x40,0x54,0x31,0x36,
+	0x43,0x30,0x30,0x31,0x53,0x61,0x6D,0x70,0x6C,0x65,0x20,0x65,
-	0x30,0x53,0x68,0x6F,0x77,0x20,0x72,0x61,0x6E,0x67,0x65,0x2E,
+	0x64,0x69,0x74,0x6F,0x72,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,
-	0x15,0x3E,0x41,0x6C,0x74,0x2B,0x5A,0x20,0x40,0x54,0x31,0x36,
+	0x30,0x40,0x43,0x30,0x30,0x32,0x1A,0x41,0x6C,0x74,0x2F,0x43,
-	0x30,0x5A,0x6F,0x6F,0x6D,0x20,0x6F,0x75,0x74,0x2E,0x1A,0x3E,
+	0x74,0x72,0x6C,0x2B,0x41,0x20,0x40,0x54,0x31,0x36,0x30,0x52,
-	0x41,0x6C,0x74,0x2B,0x58,0x20,0x6F,0x72,0x20,0x44,0x65,0x6C,
+	0x61,0x6E,0x67,0x65,0x20,0x61,0x6C,0x6C,0x2E,0x17,0x3E,0x41,
-	0x65,0x74,0x65,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x75,0x74,
+	0x6C,0x74,0x2B,0x53,0x20,0x40,0x54,0x31,0x36,0x30,0x53,0x68,
-	0x2E,0x16,0x3E,0x41,0x6C,0x74,0x2F,0x43,0x74,0x72,0x6C,0x2B,
+	0x6F,0x77,0x20,0x72,0x61,0x6E,0x67,0x65,0x2E,0x15,0x3E,0x41,
-	0x43,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x6F,0x70,0x79,0x2E,
+	0x6C,0x74,0x2B,0x5A,0x20,0x40,0x54,0x31,0x36,0x30,0x5A,0x6F,
-	0x17,0x3E,0x41,0x6C,0x74,0x2F,0x43,0x74,0x72,0x6C,0x2B,0x56,
+	0x6F,0x6D,0x20,0x6F,0x75,0x74,0x2E,0x1A,0x3E,0x41,0x6C,0x74,
-	0x20,0x40,0x54,0x31,0x36,0x30,0x50,0x61,0x73,0x74,0x65,0x2E,
+	0x2B,0x58,0x20,0x6F,0x72,0x20,0x44,0x65,0x6C,0x65,0x74,0x65,
-	0x11,0x3E,0x41,0x6C,0x74,0x2B,0x52,0x20,0x40,0x54,0x31,0x36,
+	0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x75,0x74,0x2E,0x16,0x3E,
-	0x30,0x43,0x72,0x6F,0x70,0x2E,0x2A,0x3E,0x4D,0x6F,0x75,0x73,
+	0x41,0x6C,0x74,0x2F,0x43,0x74,0x72,0x6C,0x2B,0x43,0x20,0x40,
-	0x65,0x20,0x77,0x68,0x65,0x65,0x6C,0x20,0x40,0x54,0x31,0x36,
+	0x54,0x31,0x36,0x30,0x43,0x6F,0x70,0x79,0x2E,0x17,0x3E,0x41,
-	0x30,0x5A,0x6F,0x6F,0x6D,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,
+	0x6C,0x74,0x2F,0x43,0x74,0x72,0x6C,0x2B,0x56,0x20,0x40,0x54,
-	0x20,0x64,0x61,0x74,0x61,0x20,0x69,0x6E,0x2F,0x6F,0x75,0x74,
+	0x31,0x36,0x30,0x50,0x61,0x73,0x74,0x65,0x2E,0x11,0x3E,0x41,
-	0x2E,0x00,0x21,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
+	0x6C,0x74,0x2B,0x52,0x20,0x40,0x54,0x31,0x36,0x30,0x43,0x72,
-	0x31,0x4E,0x6F,0x74,0x65,0x20,0x66,0x6F,0x72,0x20,0x4D,0x61,
+	0x6F,0x70,0x2E,0x2A,0x3E,0x4D,0x6F,0x75,0x73,0x65,0x20,0x77,
-	0x63,0x20,0x6B,0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x73,0x3A,
+	0x68,0x65,0x65,0x6C,0x20,0x40,0x54,0x31,0x36,0x30,0x5A,0x6F,
-	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
+	0x6F,0x6D,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x64,0x61,
-	0x3A,0x55,0x73,0x65,0x20,0x6C,0x65,0x66,0x74,0x20,0x63,0x74,
+	0x74,0x61,0x20,0x69,0x6E,0x2F,0x6F,0x75,0x74,0x2E,0x00,0x21,
-	0x72,0x6C,0x2E,0x20,0x66,0x6F,0x72,0x20,0x41,0x2F,0x58,0x2F,
+	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x4E,0x6F,
-	0x43,0x2F,0x56,0x20,0x28,0x6D,0x61,0x72,0x6B,0x20,0x61,0x6C,
+	0x74,0x65,0x20,0x66,0x6F,0x72,0x20,0x4D,0x61,0x63,0x20,0x6B,
-	0x6C,0x2F,0x63,0x75,0x74,0x2F,0x63,0x6F,0x70,0x79,0x2F,0x70,
+	0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x73,0x3A,0x0B,0x3E,0x40,
-	0x61,0x73,0x74,0x65,0x29,0x20,0x6B,0x65,0x79,0x73,0x2E,0x4B,
+	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3A,0x55,0x73,
-	0x3E,0x54,0x68,0x69,0x73,0x20,0x61,0x70,0x70,0x6C,0x69,0x65,
+	0x65,0x20,0x6C,0x65,0x66,0x74,0x20,0x63,0x74,0x72,0x6C,0x2E,
-	0x73,0x20,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x73,0x61,0x6D,
+	0x20,0x66,0x6F,0x72,0x20,0x41,0x2F,0x58,0x2F,0x43,0x2F,0x56,
-	0x70,0x6C,0x65,0x20,0x65,0x64,0x69,0x74,0x6F,0x72,0x20,0x28,
+	0x20,0x28,0x6D,0x61,0x72,0x6B,0x20,0x61,0x6C,0x6C,0x2F,0x63,
-	0x41,0x2F,0x43,0x2F,0x56,0x20,0x6F,0x6E,0x6C,0x79,0x29,0x20,
+	0x75,0x74,0x2F,0x63,0x6F,0x70,0x79,0x2F,0x70,0x61,0x73,0x74,
-	0x61,0x6E,0x64,0x20,0x74,0x65,0x78,0x74,0x20,0x6D,0x61,0x72,
+	0x65,0x29,0x20,0x6B,0x65,0x79,0x73,0x2E,0x4B,0x3E,0x54,0x68,
-	0x6B,0x69,0x6E,0x67,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,
+	0x69,0x73,0x20,0x61,0x70,0x70,0x6C,0x69,0x65,0x73,0x20,0x74,
-	0x55,0x49,0x2E,0x00,0x03,0x45,0x4E,0x44,0x4C,0x3B,0x2A,0x2A,
+	0x6F,0x20,0x74,0x68,0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,
+	0x20,0x65,0x64,0x69,0x74,0x6F,0x72,0x20,0x28,0x41,0x2F,0x43,
+	0x2F,0x56,0x20,0x6F,0x6E,0x6C,0x79,0x29,0x20,0x61,0x6E,0x64,
+	0x20,0x74,0x65,0x78,0x74,0x20,0x6D,0x61,0x72,0x6B,0x69,0x6E,
+	0x67,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x55,0x49,0x2E,
+	0x00,0x03,0x45,0x4E,0x44,0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
+	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x4C,0x3B,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
-	0x2A,0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
-	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x1B,0x40,0x4C,0x48,0x6F,0x77,
+	0x2A,0x2A,0x2A,0x1B,0x40,0x4C,0x48,0x6F,0x77,0x20,0x74,0x6F,
-	0x20,0x74,0x6F,0x20,0x75,0x73,0x65,0x20,0x46,0x61,0x73,0x74,
+	0x20,0x75,0x73,0x65,0x20,0x46,0x61,0x73,0x74,0x74,0x72,0x61,
-	0x74,0x72,0x61,0x63,0x6B,0x65,0x72,0x20,0x49,0x49,0x0B,0x3E,
+	0x63,0x6B,0x65,0x72,0x20,0x49,0x49,0x0B,0x3E,0x40,0x58,0x30,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x32,0x40,0x3E,
+	0x34,0x30,0x40,0x43,0x30,0x30,0x32,0x40,0x3E,0x41,0x6C,0x6C,
-	0x41,0x6C,0x6C,0x20,0x22,0x6E,0x6F,0x74,0x2D,0x74,0x6F,0x6F,
+	0x20,0x22,0x6E,0x6F,0x74,0x2D,0x74,0x6F,0x6F,0x2D,0x74,0x72,
-	0x2D,0x74,0x72,0x69,0x76,0x69,0x61,0x6C,0x22,0x20,0x66,0x75,
+	0x69,0x76,0x69,0x61,0x6C,0x22,0x20,0x66,0x75,0x6E,0x63,0x74,
-	0x6E,0x63,0x74,0x69,0x6F,0x6E,0x73,0x20,0x61,0x72,0x65,0x20,
+	0x69,0x6F,0x6E,0x73,0x20,0x61,0x72,0x65,0x20,0x70,0x72,0x65,
-	0x70,0x72,0x65,0x73,0x65,0x6E,0x74,0x65,0x64,0x20,0x62,0x65,
+	0x73,0x65,0x6E,0x74,0x65,0x64,0x20,0x62,0x65,0x6C,0x6F,0x77,
-	0x6C,0x6F,0x77,0x20,0x28,0x6F,0x72,0x64,0x65,0x72,0x65,0x64,
+	0x20,0x28,0x6F,0x72,0x64,0x65,0x72,0x65,0x64,0x20,0x69,0x6E,
-	0x20,0x69,0x6E,0x22,0x77,0x69,0x6E,0x64,0x6F,0x77,0x73,0x29,
+	0x22,0x77,0x69,0x6E,0x64,0x6F,0x77,0x73,0x29,0x20,0x77,0x69,
-	0x20,0x77,0x69,0x74,0x68,0x20,0x61,0x20,0x73,0x68,0x6F,0x72,
+	0x74,0x68,0x20,0x61,0x20,0x73,0x68,0x6F,0x72,0x74,0x20,0x64,
-	0x74,0x20,0x64,0x65,0x73,0x63,0x72,0x69,0x70,0x74,0x69,0x6F,
+	0x65,0x73,0x63,0x72,0x69,0x70,0x74,0x69,0x6F,0x6E,0x2E,0x00,
-	0x6E,0x2E,0x00,0x17,0x3E,0x40,0x58,0x30,0x32,0x30,0x40,0x43,
+	0x17,0x3E,0x40,0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x31,
-	0x30,0x30,0x31,0x4D,0x61,0x69,0x6E,0x20,0x73,0x63,0x72,0x65,
+	0x4D,0x61,0x69,0x6E,0x20,0x73,0x63,0x72,0x65,0x65,0x6E,0x3A,
-	0x65,0x6E,0x3A,0x01,0x3E,0x22,0x3E,0x40,0x58,0x30,0x34,0x30,
-	0x40,0x43,0x30,0x30,0x31,0x42,0x50,0x4D,0x20,0x28,0x42,0x65,
-	0x61,0x74,0x73,0x20,0x70,0x65,0x72,0x20,0x6D,0x69,0x6E,0x75,
-	0x74,0x65,0x29,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x43,0x30,0x30,0x32,0x40,0x54,0x68,0x65,0x20,0x42,0x50,0x4D,
-	0x20,0x73,0x65,0x74,0x74,0x69,0x6E,0x67,0x20,0x64,0x65,0x66,
-	0x69,0x6E,0x65,0x73,0x20,0x68,0x6F,0x77,0x20,0x66,0x61,0x73,
-	0x74,0x20,0x28,0x74,0x69,0x63,0x6B,0x73,0x2F,0x73,0x65,0x63,
-	0x6F,0x6E,0x64,0x29,0x20,0x74,0x68,0x65,0x20,0x6D,0x75,0x73,
-	0x69,0x63,0x20,0x70,0x6C,0x61,0x79,0x65,0x72,0x1C,0x77,0x69,
-	0x6C,0x6C,0x20,0x72,0x75,0x6E,0x2E,0x20,0x31,0x32,0x35,0x20,
-	0x42,0x50,0x4D,0x20,0x3C,0x2D,0x3E,0x20,0x35,0x30,0x20,0x48,
-	0x7A,0x2E,0x28,0x3E,0x4E,0x75,0x6D,0x62,0x65,0x72,0x20,0x6F,
-	0x66,0x20,0x70,0x6C,0x61,0x79,0x65,0x72,0x20,0x74,0x69,0x63,
-	0x6B,0x73,0x2F,0x73,0x65,0x63,0x6F,0x6E,0x64,0x20,0x3D,0x20,
-	0x42,0x50,0x4D,0x2A,0x32,0x2F,0x35,0x00,0x16,0x3E,0x40,0x58,
-	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x70,0x64,0x2C,
-	0x20,0x53,0x70,0x65,0x65,0x64,0x3A,0x0B,0x3E,0x40,0x58,0x30,
-	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x2C,0x53,0x70,0x65,0x65,
-	0x64,0x20,0x3D,0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x20,0x6F,
-	0x66,0x20,0x70,0x6C,0x61,0x79,0x65,0x72,0x20,0x74,0x69,0x63,
-	0x6B,0x73,0x2F,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x6C,
-	0x69,0x6E,0x65,0x2E,0x00,0x0F,0x3E,0x40,0x58,0x30,0x34,0x30,
-	0x40,0x43,0x30,0x30,0x31,0x41,0x64,0x64,0x3A,0x0B,0x3E,0x40,
-	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3E,0x22,0x41,
-	0x64,0x64,0x22,0x20,0x69,0x73,0x20,0x74,0x68,0x65,0x20,0x6E,
-	0x75,0x6D,0x62,0x65,0x72,0x20,0x6F,0x66,0x20,0x70,0x61,0x74,
-	0x74,0x65,0x72,0x6E,0x20,0x6C,0x69,0x6E,0x65,0x73,0x20,0x74,
-	0x68,0x65,0x20,0x63,0x75,0x72,0x73,0x6F,0x72,0x20,0x6A,0x75,
-	0x6D,0x70,0x73,0x20,0x77,0x68,0x65,0x6E,0x20,0x79,0x6F,0x75,
-	0x0C,0x65,0x64,0x69,0x74,0x20,0x61,0x20,0x6E,0x6F,0x74,0x65,
-	0x2E,0x00,0x0F,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
-	0x30,0x31,0x50,0x74,0x6E,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,
-	0x30,0x40,0x43,0x30,0x30,0x32,0x1B,0x54,0x68,0x65,0x20,0x63,
-	0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x70,0x61,0x74,0x74,0x65,
-	0x72,0x6E,0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x2E,0x00,0x0E,
-	0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x4C,
-	0x6E,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
-	0x30,0x32,0x43,0x54,0x68,0x65,0x20,0x6E,0x75,0x6D,0x62,0x65,
-	0x72,0x20,0x6F,0x66,0x20,0x6C,0x69,0x6E,0x65,0x73,0x20,0x66,
-	0x6F,0x72,0x20,0x74,0x68,0x65,0x20,0x63,0x75,0x72,0x72,0x65,
-	0x6E,0x74,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x20,
-	0x55,0x70,0x20,0x74,0x6F,0x20,0x24,0x31,0x30,0x30,0x20,0x6C,
-	0x69,0x6E,0x65,0x73,0x2E,0x20,0x4E,0x6F,0x74,0x65,0x40,0x74,
-	0x68,0x61,0x74,0x20,0x46,0x54,0x32,0x20,0x77,0x6F,0x6E,0x27,
-	0x74,0x20,0x77,0x61,0x72,0x6E,0x20,0x79,0x6F,0x75,0x20,0x69,
-	0x66,0x20,0x79,0x6F,0x75,0x20,0x64,0x65,0x63,0x72,0x65,0x61,
-	0x73,0x65,0x20,0x74,0x68,0x69,0x73,0x20,0x76,0x61,0x6C,0x75,
-	0x65,0x2E,0x20,0x54,0x68,0x65,0x20,0x6E,0x6F,0x74,0x65,0x73,
-	0x20,0x61,0x74,0x37,0x74,0x68,0x65,0x20,0x62,0x6F,0x74,0x74,
-	0x6F,0x6D,0x20,0x6C,0x69,0x6E,0x65,0x20,0x77,0x69,0x6C,0x6C,
-	0x20,0x62,0x65,0x20,0x74,0x68,0x72,0x6F,0x77,0x6E,0x20,0x6F,
-	0x75,0x74,0x20,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x62,0x69,
-	0x6E,0x61,0x72,0x79,0x20,0x73,0x70,0x61,0x63,0x65,0x2E,0x00,
-	0x10,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
-	0x45,0x78,0x70,0x64,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,
-	0x40,0x43,0x30,0x30,0x32,0x44,0x45,0x78,0x70,0x61,0x6E,0x64,
-	0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x20,0x49,0x6E,
-	0x73,0x65,0x72,0x74,0x73,0x20,0x61,0x20,0x62,0x6C,0x61,0x6E,
-	0x6B,0x20,0x6C,0x69,0x6E,0x65,0x20,0x61,0x66,0x74,0x65,0x72,
-	0x20,0x65,0x61,0x63,0x68,0x20,0x70,0x61,0x74,0x74,0x65,0x72,
-	0x6E,0x20,0x6C,0x69,0x6E,0x65,0x2E,0x20,0x55,0x73,0x65,0x66,
-	0x75,0x6C,0x3C,0x69,0x66,0x20,0x79,0x6F,0x75,0x20,0x77,0x61,
-	0x6E,0x74,0x20,0x74,0x6F,0x20,0x63,0x6F,0x6E,0x76,0x65,0x72,
-	0x74,0x20,0x61,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,
-	0x74,0x68,0x61,0x74,0x20,0x72,0x75,0x6E,0x73,0x20,0x69,0x6E,
-	0x20,0x73,0x70,0x65,0x65,0x64,0x20,0x32,0x2A,0x78,0x20,0x74,
-	0x6F,0x20,0x61,0x1D,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,
-	0x74,0x68,0x61,0x74,0x20,0x72,0x75,0x6E,0x73,0x20,0x69,0x6E,
-	0x20,0x73,0x70,0x65,0x65,0x64,0x20,0x78,0x2E,0x00,0x10,0x3E,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x68,
-	0x6E,0x6B,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
-	0x30,0x30,0x32,0x2E,0x53,0x68,0x72,0x69,0x6E,0x6B,0x20,0x70,
-	0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x20,0x44,0x65,0x6C,0x65,
-	0x74,0x65,0x73,0x20,0x61,0x6C,0x6C,0x20,0x6F,0x64,0x64,0x20,
-	0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x6C,0x69,0x6E,0x65,
-	0x73,0x2E,0x00,0x2A,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,
-	0x30,0x30,0x31,0x54,0x68,0x65,0x20,0x69,0x6E,0x73,0x74,0x72,
-	0x75,0x6D,0x65,0x6E,0x74,0x2F,0x73,0x61,0x6D,0x70,0x6C,0x65,
-	0x20,0x73,0x65,0x6C,0x65,0x63,0x74,0x6F,0x72,0x3A,0x0B,0x3E,
-	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3A,0x54,
-	0x68,0x65,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,
-	0x74,0x20,0x74,0x68,0x61,0x74,0x20,0x68,0x61,0x73,0x20,0x61,
-	0x20,0x6D,0x61,0x72,0x6B,0x20,0x6F,0x6E,0x20,0x69,0x74,0x27,
-	0x73,0x20,0x6E,0x61,0x6D,0x65,0x20,0x73,0x74,0x72,0x69,0x6E,
-	0x67,0x2C,0x20,0x69,0x73,0x20,0x74,0x68,0x65,0x17,0x64,0x65,
-	0x73,0x74,0x69,0x6E,0x61,0x74,0x69,0x6F,0x6E,0x20,0x69,0x6E,
-	0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x2E,0x3D,0x3E,0x54,
-	0x68,0x65,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,
-	0x74,0x20,0x74,0x68,0x61,0x74,0x20,0x68,0x61,0x73,0x20,0x61,
-	0x20,0x6D,0x61,0x72,0x6B,0x20,0x6F,0x6E,0x20,0x69,0x74,0x27,
-	0x73,0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x2C,0x20,0x69,0x73,
-	0x20,0x74,0x68,0x65,0x20,0x73,0x6F,0x75,0x72,0x63,0x65,0x0B,
-	0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x2E,0x1F,
-	0x3E,0x54,0x68,0x65,0x20,0x73,0x61,0x6D,0x65,0x20,0x67,0x6F,
-	0x65,0x73,0x20,0x66,0x6F,0x72,0x20,0x74,0x68,0x65,0x20,0x73,
-	0x61,0x6D,0x70,0x6C,0x65,0x73,0x2E,0x42,0x3E,0x59,0x6F,0x75,
-	0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x20,0x74,0x68,0x65,0x20,
-	0x6E,0x61,0x6D,0x65,0x20,0x6F,0x6E,0x20,0x61,0x6E,0x20,0x69,
-	0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x2F,0x73,0x61,
-	0x6D,0x70,0x6C,0x65,0x20,0x62,0x79,0x20,0x63,0x6C,0x69,0x63,
-	0x6B,0x69,0x6E,0x67,0x20,0x74,0x68,0x65,0x20,0x72,0x69,0x67,
-	0x68,0x74,0x07,0x62,0x75,0x74,0x74,0x6F,0x6E,0x2E,0x00,0x12,
-	0x3E,0x40,0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x31,0x53,
-	0x63,0x6F,0x70,0x65,0x73,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,
-	0x30,0x40,0x43,0x30,0x30,0x32,0x22,0x3E,0x4C,0x65,0x66,0x74,
-	0x20,0x62,0x75,0x74,0x74,0x6F,0x6E,0x3A,0x20,0x54,0x75,0x72,
-	0x6E,0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x20,0x6F,0x6E,
-	0x2F,0x6F,0x66,0x66,0x2E,0x35,0x3E,0x52,0x69,0x67,0x68,0x74,
-	0x20,0x62,0x75,0x74,0x74,0x6F,0x6E,0x3A,0x20,0x54,0x75,0x72,
-	0x6E,0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x20,0x6D,0x75,
-	0x6C,0x74,0x69,0x2D,0x72,0x65,0x63,0x6F,0x72,0x64,0x2F,0x65,
-	0x64,0x69,0x74,0x20,0x6F,0x6E,0x2F,0x6F,0x66,0x66,0x2E,0x42,
-	0x3E,0x4C,0x65,0x66,0x74,0x2B,0x72,0x69,0x67,0x68,0x74,0x20,
-	0x62,0x75,0x74,0x74,0x6F,0x6E,0x3A,0x20,0x54,0x75,0x72,0x6E,
-	0x20,0x61,0x6C,0x6C,0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,
-	0x73,0x20,0x6F,0x66,0x66,0x20,0x65,0x78,0x63,0x65,0x70,0x74,
-	0x20,0x74,0x68,0x65,0x20,0x73,0x65,0x6C,0x65,0x63,0x74,0x65,
-	0x64,0x20,0x6F,0x6E,0x65,0x2E,0x00,0x1C,0x40,0x58,0x30,0x32,
-	0x30,0x40,0x43,0x30,0x30,0x31,0x49,0x6E,0x73,0x74,0x72,0x75,
-	0x6D,0x65,0x6E,0x74,0x20,0x45,0x64,0x69,0x74,0x6F,0x72,0x3A,
 	0x01,0x3E,0x22,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
-	0x30,0x31,0x57,0x68,0x61,0x74,0x20,0x69,0x73,0x20,0x61,0x6E,
+	0x30,0x31,0x42,0x50,0x4D,0x20,0x28,0x42,0x65,0x61,0x74,0x73,
-	0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x3F,
+	0x20,0x70,0x65,0x72,0x20,0x6D,0x69,0x6E,0x75,0x74,0x65,0x29,
-	0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,
-	0x32,0x1E,0x41,0x20,0x46,0x61,0x73,0x74,0x74,0x72,0x61,0x63,
-	0x6B,0x65,0x72,0x20,0x32,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,
-	0x6D,0x65,0x6E,0x74,0x20,0x69,0x73,0x3A,0x15,0x3E,0x20,0x20,
-	0x20,0x31,0x20,0x56,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x65,0x6E,
-	0x76,0x65,0x6C,0x6F,0x70,0x65,0x16,0x3E,0x20,0x20,0x20,0x31,
-	0x20,0x50,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x65,0x6E,0x76,
-	0x65,0x6C,0x6F,0x70,0x65,0x1D,0x3E,0x20,0x20,0x20,0x31,0x20,
-	0x41,0x75,0x74,0x6F,0x2D,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,
-	0x20,0x64,0x65,0x66,0x69,0x6E,0x69,0x74,0x69,0x6F,0x6E,0x13,
-	0x3E,0x20,0x20,0x20,0x31,0x2E,0x2E,0x31,0x36,0x20,0x53,0x61,
-	0x6D,0x70,0x6C,0x65,0x28,0x73,0x29,0x1F,0x3E,0x20,0x20,0x20,
-	0x31,0x20,0x4B,0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x20,0x73,
-	0x70,0x6C,0x69,0x74,0x20,0x64,0x65,0x66,0x69,0x6E,0x69,0x74,
-	0x69,0x6F,0x6E,0x15,0x3E,0x20,0x20,0x20,0x31,0x20,0x4D,0x49,
-	0x44,0x49,0x20,0x64,0x65,0x66,0x69,0x6E,0x69,0x74,0x69,0x6F,
-	0x6E,0x00,0x1B,0x3E,0x41,0x20,0x46,0x61,0x73,0x74,0x74,0x72,
-	0x61,0x63,0x6B,0x65,0x72,0x20,0x32,0x20,0x73,0x61,0x6D,0x70,
-	0x6C,0x65,0x20,0x69,0x73,0x3A,0x29,0x3E,0x20,0x20,0x20,0x31,
-	0x20,0x56,0x6F,0x6C,0x75,0x6D,0x65,0x2F,0x50,0x61,0x6E,0x6E,
-	0x69,0x6E,0x67,0x2F,0x46,0x69,0x6E,0x65,0x2D,0x74,0x75,0x6E,
-	0x65,0x20,0x64,0x65,0x66,0x69,0x6E,0x69,0x74,0x69,0x6F,0x6E,
-	0x14,0x3E,0x20,0x20,0x20,0x31,0x20,0x52,0x65,0x6C,0x61,0x74,
-	0x69,0x76,0x65,0x20,0x74,0x6F,0x6E,0x65,0x2E,0x10,0x3E,0x20,
-	0x20,0x20,0x31,0x20,0x57,0x61,0x76,0x65,0x20,0x66,0x6F,0x72,
-	0x6D,0x2E,0x00,0x1F,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,
-	0x30,0x30,0x31,0x54,0x68,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,
-	0x65,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x3A,0x0B,
-	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x40,
-	0x3E,0x41,0x6E,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,
-	0x6E,0x74,0x27,0x73,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,
-	0x69,0x73,0x20,0x64,0x65,0x66,0x69,0x6E,0x65,0x64,0x20,0x62,
-	0x79,0x20,0x69,0x74,0x73,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,
-	0x70,0x65,0x20,0x63,0x75,0x72,0x76,0x65,0x2E,0x20,0x49,0x66,
-	0x20,0x74,0x68,0x65,0x3E,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,
-	0x65,0x6E,0x74,0x20,0x68,0x61,0x73,0x20,0x61,0x20,0x73,0x75,
-	0x73,0x74,0x61,0x69,0x6E,0x20,0x70,0x6F,0x69,0x6E,0x74,0x2C,
-	0x20,0x74,0x68,0x65,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,
-	0x65,0x20,0x77,0x69,0x6C,0x6C,0x20,0x73,0x74,0x6F,0x70,0x20,
-	0x61,0x74,0x20,0x74,0x68,0x61,0x74,0x42,0x70,0x6F,0x69,0x6E,
-	0x74,0x20,0x75,0x6E,0x74,0x69,0x6C,0x20,0x61,0x20,0x6B,0x65,
-	0x79,0x2D,0x6F,0x66,0x66,0x20,0x6E,0x6F,0x74,0x65,0x20,0x68,
-	0x61,0x73,0x20,0x62,0x65,0x65,0x6E,0x20,0x70,0x6C,0x61,0x79,
-	0x65,0x64,0x2E,0x20,0x57,0x68,0x65,0x6E,0x20,0x61,0x20,0x6B,
-	0x65,0x79,0x2D,0x6F,0x66,0x66,0x20,0x6E,0x6F,0x74,0x65,0x20,
-	0x69,0x73,0x1D,0x70,0x6C,0x61,0x79,0x65,0x64,0x2C,0x20,0x74,
-	0x68,0x65,0x20,0x22,0x66,0x61,0x64,0x65,0x6F,0x75,0x74,0x22,
-	0x20,0x62,0x65,0x67,0x69,0x6E,0x73,0x2E,0x44,0x3E,0x4F,0x6E,
-	0x65,0x20,0x70,0x69,0x78,0x65,0x6C,0x20,0x69,0x6E,0x20,0x74,
-	0x68,0x65,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x20,
-	0x77,0x69,0x6E,0x64,0x6F,0x77,0x20,0x63,0x6F,0x72,0x72,0x65,
-	0x73,0x70,0x6F,0x6E,0x64,0x73,0x20,0x74,0x6F,0x20,0x6F,0x6E,
-	0x65,0x20,0x70,0x6C,0x61,0x79,0x65,0x72,0x2D,0x74,0x69,0x63,
-	0x6B,0x2E,0x20,0x49,0x66,0x3C,0x74,0x68,0x65,0x20,0x42,0x50,
-	0x4D,0x20,0x69,0x73,0x20,0x31,0x32,0x35,0x2C,0x20,0x79,0x6F,
-	0x75,0x27,0x6C,0x6C,0x20,0x63,0x6F,0x6E,0x73,0x75,0x6D,0x65,
-	0x20,0x35,0x30,0x20,0x70,0x69,0x78,0x65,0x6C,0x2F,0x73,0x65,
-	0x63,0x6F,0x6E,0x64,0x2E,0x20,0x54,0x68,0x65,0x20,0x77,0x69,
-	0x6E,0x64,0x6F,0x77,0x27,0x73,0x1A,0x22,0x73,0x69,0x7A,0x65,
-	0x22,0x20,0x69,0x73,0x20,0x61,0x62,0x6F,0x75,0x74,0x20,0x36,
-	0x20,0x73,0x65,0x63,0x6F,0x6E,0x64,0x73,0x2E,0x3E,0x3E,0x49,
-	0x66,0x20,0x79,0x6F,0x75,0x20,0x70,0x72,0x65,0x73,0x73,0x20,
-	0x74,0x68,0x65,0x20,0x72,0x69,0x67,0x68,0x74,0x20,0x6D,0x6F,
-	0x75,0x73,0x65,0x20,0x62,0x75,0x74,0x74,0x6F,0x6E,0x20,0x61,
-	0x74,0x20,0x74,0x68,0x65,0x20,0x70,0x72,0x65,0x64,0x65,0x66,
-	0x69,0x6E,0x65,0x20,0x62,0x75,0x74,0x74,0x6F,0x6E,0x73,0x2C,
-	0x3F,0x79,0x6F,0x75,0x27,0x6C,0x6C,0x20,0x73,0x74,0x6F,0x72,
-	0x65,0x20,0x74,0x68,0x65,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,
-	0x74,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x20,0x69,
-	0x6E,0x74,0x6F,0x20,0x74,0x68,0x61,0x74,0x20,0x70,0x72,0x65,
-	0x64,0x65,0x66,0x69,0x6E,0x65,0x20,0x63,0x65,0x6C,0x6C,0x2E,
-	0x20,0x54,0x68,0x65,0x30,0x70,0x72,0x65,0x64,0x65,0x66,0x69,
-	0x6E,0x65,0x73,0x20,0x61,0x72,0x65,0x20,0x73,0x74,0x6F,0x72,
-	0x65,0x64,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x63,0x6F,
-	0x6E,0x66,0x69,0x67,0x75,0x72,0x61,0x74,0x69,0x6F,0x6E,0x20,
-	0x66,0x69,0x6C,0x65,0x2E,0x43,0x3E,0x50,0x72,0x65,0x64,0x65,
-	0x66,0x69,0x6E,0x65,0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x20,
-	0x31,0x20,0x69,0x73,0x20,0x74,0x68,0x65,0x20,0x64,0x65,0x66,
-	0x61,0x75,0x6C,0x74,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,
-	0x65,0x2E,0x20,0x54,0x68,0x69,0x73,0x20,0x6D,0x65,0x61,0x6E,
-	0x73,0x20,0x74,0x68,0x61,0x74,0x20,0x69,0x66,0x20,0x79,0x6F,
-	0x75,0x42,0x6C,0x6F,0x61,0x64,0x20,0x61,0x20,0x73,0x61,0x6D,
-	0x70,0x6C,0x65,0x2C,0x20,0x69,0x74,0x20,0x77,0x69,0x6C,0x6C,
-	0x20,0x67,0x65,0x74,0x20,0x61,0x6C,0x6C,0x20,0x65,0x6E,0x76,
-	0x65,0x6C,0x6F,0x70,0x65,0x20,0x69,0x6E,0x66,0x6F,0x72,0x6D,
-	0x61,0x74,0x69,0x6F,0x6E,0x20,0x66,0x72,0x6F,0x6D,0x20,0x70,
-	0x72,0x65,0x64,0x65,0x66,0x69,0x6E,0x65,0x20,0x6E,0x75,0x6D,
-	0x62,0x65,0x72,0x20,0x31,0x2C,0x20,0x69,0x6E,0x63,0x6C,0x75,
-	0x64,0x69,0x6E,0x67,0x20,0x74,0x68,0x65,0x20,0x76,0x69,0x62,
-	0x72,0x61,0x74,0x6F,0x2E,0x42,0x3E,0x4E,0x6F,0x74,0x65,0x20,
-	0x74,0x68,0x61,0x74,0x20,0x69,0x66,0x20,0x79,0x6F,0x75,0x20,
-	0x74,0x75,0x72,0x6E,0x20,0x74,0x68,0x65,0x20,0x76,0x6F,0x6C,
-	0x75,0x6D,0x65,0x2D,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,
-	0x20,0x6F,0x66,0x66,0x2C,0x20,0x79,0x6F,0x75,0x20,0x64,0x6F,
-	0x6E,0x27,0x74,0x20,0x74,0x75,0x72,0x6E,0x20,0x74,0x68,0x65,
-	0x0C,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x6F,0x66,0x66,
-	0x2E,0x00,0x20,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
-	0x30,0x31,0x54,0x68,0x65,0x20,0x70,0x61,0x6E,0x6E,0x69,0x6E,
-	0x67,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x3A,0x0B,
-	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x40,
-	0x3E,0x53,0x61,0x6D,0x65,0x20,0x61,0x73,0x20,0x61,0x62,0x6F,
-	0x76,0x65,0x2C,0x20,0x65,0x78,0x63,0x65,0x70,0x74,0x20,0x66,
-	0x72,0x6F,0x6D,0x20,0x74,0x68,0x61,0x74,0x20,0x74,0x68,0x65,
-	0x20,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x69,0x73,0x20,
-	0x6E,0x6F,0x74,0x20,0x63,0x6F,0x6E,0x6E,0x65,0x63,0x74,0x65,
-	0x64,0x20,0x74,0x6F,0x15,0x74,0x68,0x65,0x20,0x70,0x61,0x6E,
-	0x6E,0x69,0x6E,0x67,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,
-	0x65,0x2E,0x00,0x10,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,
-	0x30,0x30,0x31,0x54,0x75,0x6E,0x65,0x3A,0x0B,0x3E,0x40,0x58,
-	0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3F,0x3E,0x54,0x68,
-	0x65,0x20,0x66,0x69,0x6E,0x65,0x2D,0x74,0x75,0x6E,0x65,0x20,
-	0x72,0x65,0x73,0x6F,0x6C,0x75,0x74,0x69,0x6F,0x6E,0x20,0x68,
-	0x61,0x73,0x20,0x62,0x65,0x65,0x6E,0x20,0x63,0x68,0x61,0x6E,
-	0x67,0x65,0x64,0x20,0x66,0x72,0x6F,0x6D,0x20,0x61,0x20,0x73,
-	0x69,0x67,0x6E,0x65,0x64,0x20,0x6E,0x69,0x62,0x62,0x6C,0x65,
-	0x27,0x28,0x2D,0x38,0x2E,0x2E,0x2B,0x37,0x29,0x20,0x74,0x6F,
-	0x20,0x61,0x20,0x73,0x69,0x67,0x6E,0x65,0x64,0x20,0x62,0x79,
-	0x74,0x65,0x20,0x28,0x2D,0x31,0x32,0x38,0x2E,0x2E,0x2B,0x31,
-	0x32,0x37,0x29,0x2E,0x00,0x13,0x3E,0x40,0x58,0x30,0x34,0x30,
-	0x40,0x43,0x30,0x30,0x31,0x46,0x61,0x64,0x65,0x6F,0x75,0x74,
 	0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,
-	0x32,0x1B,0x3E,0x54,0x68,0x69,0x73,0x20,0x69,0x73,0x20,0x74,
+	0x32,0x40,0x54,0x68,0x65,0x20,0x42,0x50,0x4D,0x20,0x73,0x65,
-	0x68,0x65,0x20,0x66,0x61,0x64,0x65,0x6F,0x75,0x74,0x20,0x73,
+	0x74,0x74,0x69,0x6E,0x67,0x20,0x64,0x65,0x66,0x69,0x6E,0x65,
-	0x70,0x65,0x65,0x64,0x2E,0x00,0x19,0x3E,0x40,0x58,0x30,0x34,
+	0x73,0x20,0x68,0x6F,0x77,0x20,0x66,0x61,0x73,0x74,0x20,0x28,
-	0x30,0x40,0x43,0x30,0x30,0x31,0x56,0x69,0x62,0x72,0x61,0x74,
+	0x74,0x69,0x63,0x6B,0x73,0x2F,0x73,0x65,0x63,0x6F,0x6E,0x64,
-	0x6F,0x20,0x73,0x77,0x65,0x65,0x70,0x3A,0x0B,0x3E,0x40,0x58,
+	0x29,0x20,0x74,0x68,0x65,0x20,0x6D,0x75,0x73,0x69,0x63,0x20,
-	0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3E,0x3E,0x54,0x68,
+	0x70,0x6C,0x61,0x79,0x65,0x72,0x1C,0x77,0x69,0x6C,0x6C,0x20,
-	0x69,0x73,0x20,0x69,0x73,0x20,0x74,0x68,0x65,0x20,0x74,0x69,
+	0x72,0x75,0x6E,0x2E,0x20,0x31,0x32,0x35,0x20,0x42,0x50,0x4D,
-	0x6D,0x65,0x20,0x28,0x69,0x6E,0x20,0x70,0x6C,0x61,0x79,0x65,
+	0x20,0x3C,0x2D,0x3E,0x20,0x35,0x30,0x20,0x48,0x7A,0x2E,0x28,
-	0x72,0x20,0x74,0x69,0x63,0x6B,0x73,0x29,0x20,0x74,0x68,0x61,
+	0x3E,0x4E,0x75,0x6D,0x62,0x65,0x72,0x20,0x6F,0x66,0x20,0x70,
-	0x74,0x20,0x77,0x69,0x6C,0x6C,0x20,0x62,0x79,0x70,0x61,0x73,
+	0x6C,0x61,0x79,0x65,0x72,0x20,0x74,0x69,0x63,0x6B,0x73,0x2F,
-	0x73,0x20,0x75,0x6E,0x74,0x69,0x6C,0x20,0x74,0x68,0x65,0x2D,
+	0x73,0x65,0x63,0x6F,0x6E,0x64,0x20,0x3D,0x20,0x42,0x50,0x4D,
-	0x61,0x75,0x74,0x6F,0x2D,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,
+	0x2A,0x32,0x2F,0x35,0x00,0x16,0x3E,0x40,0x58,0x30,0x34,0x30,
-	0x20,0x77,0x69,0x6C,0x6C,0x20,0x72,0x65,0x61,0x63,0x68,0x20,
+	0x40,0x43,0x30,0x30,0x31,0x53,0x70,0x64,0x2C,0x20,0x53,0x70,
-	0x69,0x74,0x27,0x73,0x20,0x66,0x69,0x6E,0x61,0x6C,0x20,0x61,
+	0x65,0x65,0x64,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x6D,0x70,0x6C,0x69,0x74,0x75,0x64,0x65,0x2E,0x00,0x1E,0x3E,
+	0x43,0x30,0x30,0x32,0x2C,0x53,0x70,0x65,0x65,0x64,0x20,0x3D,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x54,0x68,
+	0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x20,0x6F,0x66,0x20,0x70,
-	0x65,0x20,0x70,0x69,0x61,0x6E,0x6F,0x20,0x6B,0x65,0x79,0x62,
+	0x6C,0x61,0x79,0x65,0x72,0x20,0x74,0x69,0x63,0x6B,0x73,0x2F,
-	0x6F,0x61,0x72,0x64,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,
+	0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x6C,0x69,0x6E,0x65,
-	0x40,0x43,0x30,0x30,0x32,0x3F,0x3E,0x54,0x68,0x65,0x20,0x70,
+	0x2E,0x00,0x0F,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
+	0x30,0x31,0x41,0x64,0x64,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,
+	0x30,0x40,0x43,0x30,0x30,0x32,0x3E,0x22,0x41,0x64,0x64,0x22,
+	0x20,0x69,0x73,0x20,0x74,0x68,0x65,0x20,0x6E,0x75,0x6D,0x62,
+	0x65,0x72,0x20,0x6F,0x66,0x20,0x70,0x61,0x74,0x74,0x65,0x72,
+	0x6E,0x20,0x6C,0x69,0x6E,0x65,0x73,0x20,0x74,0x68,0x65,0x20,
+	0x63,0x75,0x72,0x73,0x6F,0x72,0x20,0x6A,0x75,0x6D,0x70,0x73,
+	0x20,0x77,0x68,0x65,0x6E,0x20,0x79,0x6F,0x75,0x0C,0x65,0x64,
+	0x69,0x74,0x20,0x61,0x20,0x6E,0x6F,0x74,0x65,0x2E,0x00,0x0F,
+	0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x50,
+	0x74,0x6E,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
+	0x30,0x30,0x32,0x1B,0x54,0x68,0x65,0x20,0x63,0x75,0x72,0x72,
+	0x65,0x6E,0x74,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,
+	0x6E,0x75,0x6D,0x62,0x65,0x72,0x2E,0x00,0x0E,0x3E,0x40,0x58,
+	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x4C,0x6E,0x3A,0x0B,
+	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x43,
+	0x54,0x68,0x65,0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x20,0x6F,
+	0x66,0x20,0x6C,0x69,0x6E,0x65,0x73,0x20,0x66,0x6F,0x72,0x20,
+	0x74,0x68,0x65,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,
+	0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x2E,0x20,0x55,0x70,0x20,
+	0x74,0x6F,0x20,0x24,0x31,0x30,0x30,0x20,0x6C,0x69,0x6E,0x65,
+	0x73,0x2E,0x20,0x4E,0x6F,0x74,0x65,0x40,0x74,0x68,0x61,0x74,
+	0x20,0x46,0x54,0x32,0x20,0x77,0x6F,0x6E,0x27,0x74,0x20,0x77,
+	0x61,0x72,0x6E,0x20,0x79,0x6F,0x75,0x20,0x69,0x66,0x20,0x79,
+	0x6F,0x75,0x20,0x64,0x65,0x63,0x72,0x65,0x61,0x73,0x65,0x20,
+	0x74,0x68,0x69,0x73,0x20,0x76,0x61,0x6C,0x75,0x65,0x2E,0x20,
+	0x54,0x68,0x65,0x20,0x6E,0x6F,0x74,0x65,0x73,0x20,0x61,0x74,
+	0x37,0x74,0x68,0x65,0x20,0x62,0x6F,0x74,0x74,0x6F,0x6D,0x20,
+	0x6C,0x69,0x6E,0x65,0x20,0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,
+	0x20,0x74,0x68,0x72,0x6F,0x77,0x6E,0x20,0x6F,0x75,0x74,0x20,
+	0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x62,0x69,0x6E,0x61,0x72,
+	0x79,0x20,0x73,0x70,0x61,0x63,0x65,0x2E,0x00,0x10,0x3E,0x40,
+	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x45,0x78,0x70,
+	0x64,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
+	0x30,0x32,0x44,0x45,0x78,0x70,0x61,0x6E,0x64,0x20,0x70,0x61,
+	0x74,0x74,0x65,0x72,0x6E,0x2E,0x20,0x49,0x6E,0x73,0x65,0x72,
+	0x74,0x73,0x20,0x61,0x20,0x62,0x6C,0x61,0x6E,0x6B,0x20,0x6C,
+	0x69,0x6E,0x65,0x20,0x61,0x66,0x74,0x65,0x72,0x20,0x65,0x61,
+	0x63,0x68,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x6C,
+	0x69,0x6E,0x65,0x2E,0x20,0x55,0x73,0x65,0x66,0x75,0x6C,0x3C,
+	0x69,0x66,0x20,0x79,0x6F,0x75,0x20,0x77,0x61,0x6E,0x74,0x20,
+	0x74,0x6F,0x20,0x63,0x6F,0x6E,0x76,0x65,0x72,0x74,0x20,0x61,
+	0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x74,0x68,0x61,
+	0x74,0x20,0x72,0x75,0x6E,0x73,0x20,0x69,0x6E,0x20,0x73,0x70,
+	0x65,0x65,0x64,0x20,0x32,0x2A,0x78,0x20,0x74,0x6F,0x20,0x61,
+	0x1D,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x74,0x68,0x61,
+	0x74,0x20,0x72,0x75,0x6E,0x73,0x20,0x69,0x6E,0x20,0x73,0x70,
+	0x65,0x65,0x64,0x20,0x78,0x2E,0x00,0x10,0x3E,0x40,0x58,0x30,
+	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x68,0x6E,0x6B,0x3A,
+	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
+	0x2E,0x53,0x68,0x72,0x69,0x6E,0x6B,0x20,0x70,0x61,0x74,0x74,
+	0x65,0x72,0x6E,0x2E,0x20,0x44,0x65,0x6C,0x65,0x74,0x65,0x73,
+	0x20,0x61,0x6C,0x6C,0x20,0x6F,0x64,0x64,0x20,0x70,0x61,0x74,
+	0x74,0x65,0x72,0x6E,0x20,0x6C,0x69,0x6E,0x65,0x73,0x2E,0x00,
+	0x2A,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
+	0x54,0x68,0x65,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,
+	0x6E,0x74,0x2F,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x73,0x65,
+	0x6C,0x65,0x63,0x74,0x6F,0x72,0x3A,0x0B,0x3E,0x40,0x58,0x30,
+	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3A,0x54,0x68,0x65,0x20,
+	0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x74,
+	0x68,0x61,0x74,0x20,0x68,0x61,0x73,0x20,0x61,0x20,0x6D,0x61,
+	0x72,0x6B,0x20,0x6F,0x6E,0x20,0x69,0x74,0x27,0x73,0x20,0x6E,
+	0x61,0x6D,0x65,0x20,0x73,0x74,0x72,0x69,0x6E,0x67,0x2C,0x20,
+	0x69,0x73,0x20,0x74,0x68,0x65,0x17,0x64,0x65,0x73,0x74,0x69,
+	0x6E,0x61,0x74,0x69,0x6F,0x6E,0x20,0x69,0x6E,0x73,0x74,0x72,
+	0x75,0x6D,0x65,0x6E,0x74,0x2E,0x3D,0x3E,0x54,0x68,0x65,0x20,
+	0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x74,
+	0x68,0x61,0x74,0x20,0x68,0x61,0x73,0x20,0x61,0x20,0x6D,0x61,
+	0x72,0x6B,0x20,0x6F,0x6E,0x20,0x69,0x74,0x27,0x73,0x20,0x6E,
+	0x75,0x6D,0x62,0x65,0x72,0x2C,0x20,0x69,0x73,0x20,0x74,0x68,
+	0x65,0x20,0x73,0x6F,0x75,0x72,0x63,0x65,0x0B,0x69,0x6E,0x73,
+	0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x2E,0x1F,0x3E,0x54,0x68,
+	0x65,0x20,0x73,0x61,0x6D,0x65,0x20,0x67,0x6F,0x65,0x73,0x20,
+	0x66,0x6F,0x72,0x20,0x74,0x68,0x65,0x20,0x73,0x61,0x6D,0x70,
+	0x6C,0x65,0x73,0x2E,0x42,0x3E,0x59,0x6F,0x75,0x20,0x63,0x68,
+	0x61,0x6E,0x67,0x65,0x20,0x74,0x68,0x65,0x20,0x6E,0x61,0x6D,
+	0x65,0x20,0x6F,0x6E,0x20,0x61,0x6E,0x20,0x69,0x6E,0x73,0x74,
+	0x72,0x75,0x6D,0x65,0x6E,0x74,0x2F,0x73,0x61,0x6D,0x70,0x6C,
+	0x65,0x20,0x62,0x79,0x20,0x63,0x6C,0x69,0x63,0x6B,0x69,0x6E,
+	0x67,0x20,0x74,0x68,0x65,0x20,0x72,0x69,0x67,0x68,0x74,0x07,
+	0x62,0x75,0x74,0x74,0x6F,0x6E,0x2E,0x00,0x12,0x3E,0x40,0x58,
+	0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x63,0x6F,0x70,
+	0x65,0x73,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
+	0x30,0x30,0x32,0x22,0x3E,0x4C,0x65,0x66,0x74,0x20,0x62,0x75,
+	0x74,0x74,0x6F,0x6E,0x3A,0x20,0x54,0x75,0x72,0x6E,0x20,0x63,
+	0x68,0x61,0x6E,0x6E,0x65,0x6C,0x20,0x6F,0x6E,0x2F,0x6F,0x66,
+	0x66,0x2E,0x35,0x3E,0x52,0x69,0x67,0x68,0x74,0x20,0x62,0x75,
+	0x74,0x74,0x6F,0x6E,0x3A,0x20,0x54,0x75,0x72,0x6E,0x20,0x63,
+	0x68,0x61,0x6E,0x6E,0x65,0x6C,0x20,0x6D,0x75,0x6C,0x74,0x69,
+	0x2D,0x72,0x65,0x63,0x6F,0x72,0x64,0x2F,0x65,0x64,0x69,0x74,
+	0x20,0x6F,0x6E,0x2F,0x6F,0x66,0x66,0x2E,0x42,0x3E,0x4C,0x65,
+	0x66,0x74,0x2B,0x72,0x69,0x67,0x68,0x74,0x20,0x62,0x75,0x74,
+	0x74,0x6F,0x6E,0x3A,0x20,0x54,0x75,0x72,0x6E,0x20,0x61,0x6C,
+	0x6C,0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x73,0x20,0x6F,
+	0x66,0x66,0x20,0x65,0x78,0x63,0x65,0x70,0x74,0x20,0x74,0x68,
+	0x65,0x20,0x73,0x65,0x6C,0x65,0x63,0x74,0x65,0x64,0x20,0x6F,
+	0x6E,0x65,0x2E,0x00,0x1C,0x40,0x58,0x30,0x32,0x30,0x40,0x43,
+	0x30,0x30,0x31,0x49,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,
+	0x74,0x20,0x45,0x64,0x69,0x74,0x6F,0x72,0x3A,0x01,0x3E,0x22,
+	0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x57,
+	0x68,0x61,0x74,0x20,0x69,0x73,0x20,0x61,0x6E,0x20,0x69,0x6E,
+	0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x3F,0x3A,0x0B,0x3E,
+	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x1E,0x41,
+	0x20,0x46,0x61,0x73,0x74,0x74,0x72,0x61,0x63,0x6B,0x65,0x72,
+	0x20,0x32,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,
+	0x74,0x20,0x69,0x73,0x3A,0x15,0x3E,0x20,0x20,0x20,0x31,0x20,
+	0x56,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x65,0x6E,0x76,0x65,0x6C,
+	0x6F,0x70,0x65,0x16,0x3E,0x20,0x20,0x20,0x31,0x20,0x50,0x61,
+	0x6E,0x6E,0x69,0x6E,0x67,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,
+	0x70,0x65,0x1D,0x3E,0x20,0x20,0x20,0x31,0x20,0x41,0x75,0x74,
+	0x6F,0x2D,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x64,0x65,
+	0x66,0x69,0x6E,0x69,0x74,0x69,0x6F,0x6E,0x13,0x3E,0x20,0x20,
+	0x20,0x31,0x2E,0x2E,0x31,0x36,0x20,0x53,0x61,0x6D,0x70,0x6C,
+	0x65,0x28,0x73,0x29,0x1F,0x3E,0x20,0x20,0x20,0x31,0x20,0x4B,
+	0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x20,0x73,0x70,0x6C,0x69,
+	0x74,0x20,0x64,0x65,0x66,0x69,0x6E,0x69,0x74,0x69,0x6F,0x6E,
+	0x15,0x3E,0x20,0x20,0x20,0x31,0x20,0x4D,0x49,0x44,0x49,0x20,
+	0x64,0x65,0x66,0x69,0x6E,0x69,0x74,0x69,0x6F,0x6E,0x00,0x1B,
+	0x3E,0x41,0x20,0x46,0x61,0x73,0x74,0x74,0x72,0x61,0x63,0x6B,
+	0x65,0x72,0x20,0x32,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,
+	0x69,0x73,0x3A,0x29,0x3E,0x20,0x20,0x20,0x31,0x20,0x56,0x6F,
+	0x6C,0x75,0x6D,0x65,0x2F,0x50,0x61,0x6E,0x6E,0x69,0x6E,0x67,
+	0x2F,0x46,0x69,0x6E,0x65,0x2D,0x74,0x75,0x6E,0x65,0x20,0x64,
+	0x65,0x66,0x69,0x6E,0x69,0x74,0x69,0x6F,0x6E,0x14,0x3E,0x20,
+	0x20,0x20,0x31,0x20,0x52,0x65,0x6C,0x61,0x74,0x69,0x76,0x65,
+	0x20,0x74,0x6F,0x6E,0x65,0x2E,0x10,0x3E,0x20,0x20,0x20,0x31,
+	0x20,0x57,0x61,0x76,0x65,0x20,0x66,0x6F,0x72,0x6D,0x2E,0x00,
+	0x1F,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
+	0x54,0x68,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x65,
+	0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x3A,0x0B,0x3E,0x40,0x58,
+	0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x40,0x3E,0x41,0x6E,
+	0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x27,
+	0x73,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x69,0x73,0x20,
+	0x64,0x65,0x66,0x69,0x6E,0x65,0x64,0x20,0x62,0x79,0x20,0x69,
+	0x74,0x73,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x20,
+	0x63,0x75,0x72,0x76,0x65,0x2E,0x20,0x49,0x66,0x20,0x74,0x68,
+	0x65,0x3E,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,
+	0x20,0x68,0x61,0x73,0x20,0x61,0x20,0x73,0x75,0x73,0x74,0x61,
+	0x69,0x6E,0x20,0x70,0x6F,0x69,0x6E,0x74,0x2C,0x20,0x74,0x68,
+	0x65,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x20,0x77,
+	0x69,0x6C,0x6C,0x20,0x73,0x74,0x6F,0x70,0x20,0x61,0x74,0x20,
+	0x74,0x68,0x61,0x74,0x42,0x70,0x6F,0x69,0x6E,0x74,0x20,0x75,
+	0x6E,0x74,0x69,0x6C,0x20,0x61,0x20,0x6B,0x65,0x79,0x2D,0x6F,
+	0x66,0x66,0x20,0x6E,0x6F,0x74,0x65,0x20,0x68,0x61,0x73,0x20,
+	0x62,0x65,0x65,0x6E,0x20,0x70,0x6C,0x61,0x79,0x65,0x64,0x2E,
+	0x20,0x57,0x68,0x65,0x6E,0x20,0x61,0x20,0x6B,0x65,0x79,0x2D,
+	0x6F,0x66,0x66,0x20,0x6E,0x6F,0x74,0x65,0x20,0x69,0x73,0x1D,
+	0x70,0x6C,0x61,0x79,0x65,0x64,0x2C,0x20,0x74,0x68,0x65,0x20,
+	0x22,0x66,0x61,0x64,0x65,0x6F,0x75,0x74,0x22,0x20,0x62,0x65,
+	0x67,0x69,0x6E,0x73,0x2E,0x44,0x3E,0x4F,0x6E,0x65,0x20,0x70,
+	0x69,0x78,0x65,0x6C,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,
+	0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x20,0x77,0x69,0x6E,
+	0x64,0x6F,0x77,0x20,0x63,0x6F,0x72,0x72,0x65,0x73,0x70,0x6F,
+	0x6E,0x64,0x73,0x20,0x74,0x6F,0x20,0x6F,0x6E,0x65,0x20,0x70,
+	0x6C,0x61,0x79,0x65,0x72,0x2D,0x74,0x69,0x63,0x6B,0x2E,0x20,
+	0x49,0x66,0x3C,0x74,0x68,0x65,0x20,0x42,0x50,0x4D,0x20,0x69,
+	0x73,0x20,0x31,0x32,0x35,0x2C,0x20,0x79,0x6F,0x75,0x27,0x6C,
+	0x6C,0x20,0x63,0x6F,0x6E,0x73,0x75,0x6D,0x65,0x20,0x35,0x30,
+	0x20,0x70,0x69,0x78,0x65,0x6C,0x2F,0x73,0x65,0x63,0x6F,0x6E,
+	0x64,0x2E,0x20,0x54,0x68,0x65,0x20,0x77,0x69,0x6E,0x64,0x6F,
+	0x77,0x27,0x73,0x1A,0x22,0x73,0x69,0x7A,0x65,0x22,0x20,0x69,
+	0x73,0x20,0x61,0x62,0x6F,0x75,0x74,0x20,0x36,0x20,0x73,0x65,
+	0x63,0x6F,0x6E,0x64,0x73,0x2E,0x3E,0x3E,0x49,0x66,0x20,0x79,
+	0x6F,0x75,0x20,0x70,0x72,0x65,0x73,0x73,0x20,0x74,0x68,0x65,
+	0x20,0x72,0x69,0x67,0x68,0x74,0x20,0x6D,0x6F,0x75,0x73,0x65,
+	0x20,0x62,0x75,0x74,0x74,0x6F,0x6E,0x20,0x61,0x74,0x20,0x74,
+	0x68,0x65,0x20,0x70,0x72,0x65,0x64,0x65,0x66,0x69,0x6E,0x65,
+	0x20,0x62,0x75,0x74,0x74,0x6F,0x6E,0x73,0x2C,0x3F,0x79,0x6F,
+	0x75,0x27,0x6C,0x6C,0x20,0x73,0x74,0x6F,0x72,0x65,0x20,0x74,
+	0x68,0x65,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x65,
+	0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x20,0x69,0x6E,0x74,0x6F,
+	0x20,0x74,0x68,0x61,0x74,0x20,0x70,0x72,0x65,0x64,0x65,0x66,
+	0x69,0x6E,0x65,0x20,0x63,0x65,0x6C,0x6C,0x2E,0x20,0x54,0x68,
+	0x65,0x30,0x70,0x72,0x65,0x64,0x65,0x66,0x69,0x6E,0x65,0x73,
+	0x20,0x61,0x72,0x65,0x20,0x73,0x74,0x6F,0x72,0x65,0x64,0x20,
+	0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x63,0x6F,0x6E,0x66,0x69,
+	0x67,0x75,0x72,0x61,0x74,0x69,0x6F,0x6E,0x20,0x66,0x69,0x6C,
+	0x65,0x2E,0x43,0x3E,0x50,0x72,0x65,0x64,0x65,0x66,0x69,0x6E,
+	0x65,0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x20,0x31,0x20,0x69,
+	0x73,0x20,0x74,0x68,0x65,0x20,0x64,0x65,0x66,0x61,0x75,0x6C,
+	0x74,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x2E,0x20,
+	0x54,0x68,0x69,0x73,0x20,0x6D,0x65,0x61,0x6E,0x73,0x20,0x74,
+	0x68,0x61,0x74,0x20,0x69,0x66,0x20,0x79,0x6F,0x75,0x42,0x6C,
+	0x6F,0x61,0x64,0x20,0x61,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,
+	0x2C,0x20,0x69,0x74,0x20,0x77,0x69,0x6C,0x6C,0x20,0x67,0x65,
+	0x74,0x20,0x61,0x6C,0x6C,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,
+	0x70,0x65,0x20,0x69,0x6E,0x66,0x6F,0x72,0x6D,0x61,0x74,0x69,
+	0x6F,0x6E,0x20,0x66,0x72,0x6F,0x6D,0x20,0x70,0x72,0x65,0x64,
+	0x65,0x66,0x69,0x6E,0x65,0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,
+	0x20,0x31,0x2C,0x20,0x69,0x6E,0x63,0x6C,0x75,0x64,0x69,0x6E,
+	0x67,0x20,0x74,0x68,0x65,0x20,0x76,0x69,0x62,0x72,0x61,0x74,
+	0x6F,0x2E,0x42,0x3E,0x4E,0x6F,0x74,0x65,0x20,0x74,0x68,0x61,
+	0x74,0x20,0x69,0x66,0x20,0x79,0x6F,0x75,0x20,0x74,0x75,0x72,
+	0x6E,0x20,0x74,0x68,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,
+	0x2D,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x20,0x6F,0x66,
+	0x66,0x2C,0x20,0x79,0x6F,0x75,0x20,0x64,0x6F,0x6E,0x27,0x74,
+	0x20,0x74,0x75,0x72,0x6E,0x20,0x74,0x68,0x65,0x0C,0x76,0x69,
+	0x62,0x72,0x61,0x74,0x6F,0x20,0x6F,0x66,0x66,0x2E,0x00,0x20,
+	0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x54,
+	0x68,0x65,0x20,0x70,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x65,
+	0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x3A,0x0B,0x3E,0x40,0x58,
+	0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x40,0x3E,0x53,0x61,
+	0x6D,0x65,0x20,0x61,0x73,0x20,0x61,0x62,0x6F,0x76,0x65,0x2C,
+	0x20,0x65,0x78,0x63,0x65,0x70,0x74,0x20,0x66,0x72,0x6F,0x6D,
+	0x20,0x74,0x68,0x61,0x74,0x20,0x74,0x68,0x65,0x20,0x76,0x69,
+	0x62,0x72,0x61,0x74,0x6F,0x20,0x69,0x73,0x20,0x6E,0x6F,0x74,
+	0x20,0x63,0x6F,0x6E,0x6E,0x65,0x63,0x74,0x65,0x64,0x20,0x74,
+	0x6F,0x15,0x74,0x68,0x65,0x20,0x70,0x61,0x6E,0x6E,0x69,0x6E,
+	0x67,0x20,0x65,0x6E,0x76,0x65,0x6C,0x6F,0x70,0x65,0x2E,0x00,
+	0x10,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
+	0x54,0x75,0x6E,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,
+	0x40,0x43,0x30,0x30,0x32,0x3F,0x3E,0x54,0x68,0x65,0x20,0x66,
+	0x69,0x6E,0x65,0x2D,0x74,0x75,0x6E,0x65,0x20,0x72,0x65,0x73,
+	0x6F,0x6C,0x75,0x74,0x69,0x6F,0x6E,0x20,0x68,0x61,0x73,0x20,
+	0x62,0x65,0x65,0x6E,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x64,
+	0x20,0x66,0x72,0x6F,0x6D,0x20,0x61,0x20,0x73,0x69,0x67,0x6E,
+	0x65,0x64,0x20,0x6E,0x69,0x62,0x62,0x6C,0x65,0x27,0x28,0x2D,
+	0x38,0x2E,0x2E,0x2B,0x37,0x29,0x20,0x74,0x6F,0x20,0x61,0x20,
+	0x73,0x69,0x67,0x6E,0x65,0x64,0x20,0x62,0x79,0x74,0x65,0x20,
+	0x28,0x2D,0x31,0x32,0x38,0x2E,0x2E,0x2B,0x31,0x32,0x37,0x29,
+	0x2E,0x00,0x13,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
+	0x30,0x31,0x46,0x61,0x64,0x65,0x6F,0x75,0x74,0x3A,0x0B,0x3E,
+	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x1B,0x3E,
+	0x54,0x68,0x69,0x73,0x20,0x69,0x73,0x20,0x74,0x68,0x65,0x20,
+	0x66,0x61,0x64,0x65,0x6F,0x75,0x74,0x20,0x73,0x70,0x65,0x65,
+	0x64,0x2E,0x00,0x19,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,
+	0x30,0x30,0x31,0x56,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x73,
+	0x77,0x65,0x65,0x70,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,
+	0x40,0x43,0x30,0x30,0x32,0x3E,0x3E,0x54,0x68,0x69,0x73,0x20,
+	0x69,0x73,0x20,0x74,0x68,0x65,0x20,0x74,0x69,0x6D,0x65,0x20,
+	0x28,0x69,0x6E,0x20,0x70,0x6C,0x61,0x79,0x65,0x72,0x20,0x74,
+	0x69,0x63,0x6B,0x73,0x29,0x20,0x74,0x68,0x61,0x74,0x20,0x77,
+	0x69,0x6C,0x6C,0x20,0x62,0x79,0x70,0x61,0x73,0x73,0x20,0x75,
+	0x6E,0x74,0x69,0x6C,0x20,0x74,0x68,0x65,0x2D,0x61,0x75,0x74,
+	0x6F,0x2D,0x76,0x69,0x62,0x72,0x61,0x74,0x6F,0x20,0x77,0x69,
+	0x6C,0x6C,0x20,0x72,0x65,0x61,0x63,0x68,0x20,0x69,0x74,0x27,
+	0x73,0x20,0x66,0x69,0x6E,0x61,0x6C,0x20,0x61,0x6D,0x70,0x6C,
+	0x69,0x74,0x75,0x64,0x65,0x2E,0x00,0x1E,0x3E,0x40,0x58,0x30,
+	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x54,0x68,0x65,0x20,0x70,
 	0x69,0x61,0x6E,0x6F,0x20,0x6B,0x65,0x79,0x62,0x6F,0x61,0x72,
-	0x64,0x20,0x64,0x65,0x66,0x69,0x6E,0x65,0x73,0x20,0x74,0x68,
+	0x64,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
-	0x65,0x20,0x6B,0x65,0x79,0x20,0x73,0x70,0x6C,0x69,0x74,0x20,
+	0x30,0x32,0x3F,0x3E,0x54,0x68,0x65,0x20,0x70,0x69,0x61,0x6E,
-	0x66,0x6F,0x72,0x20,0x61,0x6E,0x20,0x69,0x6E,0x73,0x74,0x72,
+	0x6F,0x20,0x6B,0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x20,0x64,
-	0x75,0x6D,0x65,0x6E,0x74,0x2E,0x20,0x54,0x6F,0x3F,0x63,0x68,
+	0x65,0x66,0x69,0x6E,0x65,0x73,0x20,0x74,0x68,0x65,0x20,0x6B,
-	0x61,0x6E,0x67,0x65,0x20,0x74,0x68,0x65,0x20,0x6B,0x65,0x79,
+	0x65,0x79,0x20,0x73,0x70,0x6C,0x69,0x74,0x20,0x66,0x6F,0x72,
-	0x20,0x73,0x70,0x6C,0x69,0x74,0x2C,0x20,0x63,0x68,0x6F,0x6F,
+	0x20,0x61,0x6E,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,
-	0x73,0x65,0x20,0x61,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,
+	0x6E,0x74,0x2E,0x20,0x54,0x6F,0x3F,0x63,0x68,0x61,0x6E,0x67,
-	0x77,0x69,0x74,0x68,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x69,
+	0x65,0x20,0x74,0x68,0x65,0x20,0x6B,0x65,0x79,0x20,0x73,0x70,
-	0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x61,0x6E,
+	0x6C,0x69,0x74,0x2C,0x20,0x63,0x68,0x6F,0x6F,0x73,0x65,0x20,
-	0x64,0x1C,0x74,0x68,0x65,0x6E,0x20,0x22,0x64,0x72,0x61,0x77,
+	0x61,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x77,0x69,0x74,
-	0x22,0x20,0x6F,0x6E,0x20,0x74,0x68,0x65,0x20,0x6B,0x65,0x79,
+	0x68,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x69,0x6E,0x73,0x74,
-	0x62,0x6F,0x61,0x72,0x64,0x2E,0x42,0x3E,0x54,0x68,0x65,0x20,
+	0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x61,0x6E,0x64,0x1C,0x74,
-	0x6E,0x6F,0x74,0x65,0x73,0x20,0x70,0x6C,0x61,0x79,0x65,0x64,
+	0x68,0x65,0x6E,0x20,0x22,0x64,0x72,0x61,0x77,0x22,0x20,0x6F,
-	0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65,0x20,0x63,0x75,
+	0x6E,0x20,0x74,0x68,0x65,0x20,0x6B,0x65,0x79,0x62,0x6F,0x61,
-	0x72,0x72,0x65,0x6E,0x74,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,
+	0x72,0x64,0x2E,0x42,0x3E,0x54,0x68,0x65,0x20,0x6E,0x6F,0x74,
-	0x6D,0x65,0x6E,0x74,0x20,0x61,0x72,0x65,0x20,0x69,0x6E,0x64,
+	0x65,0x73,0x20,0x70,0x6C,0x61,0x79,0x65,0x64,0x20,0x77,0x69,
-	0x69,0x63,0x61,0x74,0x65,0x64,0x20,0x6F,0x6E,0x20,0x74,0x68,
+	0x74,0x68,0x20,0x74,0x68,0x65,0x20,0x63,0x75,0x72,0x72,0x65,
-	0x65,0x09,0x6B,0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x2E,0x00,
+	0x6E,0x74,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,
-	0x1A,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
+	0x74,0x20,0x61,0x72,0x65,0x20,0x69,0x6E,0x64,0x69,0x63,0x61,
-	0x49,0x6D,0x70,0x6F,0x72,0x74,0x61,0x6E,0x74,0x20,0x6E,0x6F,
+	0x74,0x65,0x64,0x20,0x6F,0x6E,0x20,0x74,0x68,0x65,0x09,0x6B,
-	0x74,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
+	0x65,0x79,0x62,0x6F,0x61,0x72,0x64,0x2E,0x00,0x1A,0x3E,0x40,
-	0x30,0x30,0x32,0x40,0x3E,0x54,0x68,0x65,0x20,0x76,0x6F,0x6C,
+	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x49,0x6D,0x70,
-	0x75,0x6D,0x65,0x2C,0x20,0x70,0x61,0x6E,0x6E,0x69,0x6E,0x67,
+	0x6F,0x72,0x74,0x61,0x6E,0x74,0x20,0x6E,0x6F,0x74,0x65,0x3A,
-	0x2C,0x20,0x74,0x75,0x6E,0x65,0x20,0x61,0x6E,0x64,0x20,0x72,
+	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
-	0x65,0x6C,0x61,0x74,0x69,0x76,0x65,0x20,0x74,0x6F,0x6E,0x65,
+	0x40,0x3E,0x54,0x68,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,
-	0x20,0x69,0x73,0x20,0x64,0x65,0x66,0x69,0x6E,0x65,0x64,0x20,
+	0x2C,0x20,0x70,0x61,0x6E,0x6E,0x69,0x6E,0x67,0x2C,0x20,0x74,
-	0x66,0x6F,0x72,0x20,0x45,0x41,0x43,0x48,0x41,0x53,0x41,0x4D,
+	0x75,0x6E,0x65,0x20,0x61,0x6E,0x64,0x20,0x72,0x65,0x6C,0x61,
-	0x50,0x4C,0x45,0x20,0x69,0x6E,0x20,0x61,0x6E,0x20,0x69,0x6E,
+	0x74,0x69,0x76,0x65,0x20,0x74,0x6F,0x6E,0x65,0x20,0x69,0x73,
-	0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x2E,0x20,0x41,0x6C,
+	0x20,0x64,0x65,0x66,0x69,0x6E,0x65,0x64,0x20,0x66,0x6F,0x72,
-	0x6C,0x20,0x6F,0x74,0x68,0x65,0x72,0x20,0x69,0x6E,0x66,0x6F,
+	0x20,0x45,0x41,0x43,0x48,0x41,0x53,0x41,0x4D,0x50,0x4C,0x45,
-	0x72,0x6D,0x61,0x74,0x69,0x6F,0x6E,0x20,0x69,0x73,0x20,0x64,
+	0x20,0x69,0x6E,0x20,0x61,0x6E,0x20,0x69,0x6E,0x73,0x74,0x72,
-	0x65,0x66,0x69,0x6E,0x65,0x64,0x20,0x66,0x6F,0x72,0x20,0x74,
+	0x75,0x6D,0x65,0x6E,0x74,0x2E,0x20,0x41,0x6C,0x6C,0x20,0x6F,
-	0x68,0x65,0x12,0x65,0x6E,0x74,0x69,0x72,0x65,0x20,0x69,0x6E,
+	0x74,0x68,0x65,0x72,0x20,0x69,0x6E,0x66,0x6F,0x72,0x6D,0x61,
-	0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x2E,0x00,0x31,0x40,
+	0x74,0x69,0x6F,0x6E,0x20,0x69,0x73,0x20,0x64,0x65,0x66,0x69,
-	0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x31,0x49,0x6E,0x73,
+	0x6E,0x65,0x64,0x20,0x66,0x6F,0x72,0x20,0x74,0x68,0x65,0x12,
-	0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x45,0x64,0x69,0x74,
+	0x65,0x6E,0x74,0x69,0x72,0x65,0x20,0x69,0x6E,0x73,0x74,0x72,
-	0x6F,0x72,0x20,0x45,0x78,0x74,0x65,0x6E,0x73,0x69,0x6F,0x6E,
+	0x75,0x6D,0x65,0x6E,0x74,0x2E,0x00,0x31,0x40,0x58,0x30,0x32,
-	0x3A,0x20,0x28,0x49,0x2E,0x45,0x2E,0x45,0x78,0x74,0x2E,0x29,
+	0x30,0x40,0x43,0x30,0x30,0x31,0x49,0x6E,0x73,0x74,0x72,0x75,
-	0x01,0x3E,0x10,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
+	0x6D,0x65,0x6E,0x74,0x20,0x45,0x64,0x69,0x74,0x6F,0x72,0x20,
-	0x30,0x31,0x4D,0x49,0x44,0x49,0x3A,0x0B,0x3E,0x40,0x58,0x30,
+	0x45,0x78,0x74,0x65,0x6E,0x73,0x69,0x6F,0x6E,0x3A,0x20,0x28,
-	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x28,0x3E,0x27,0x70,0x2E,
+	0x49,0x2E,0x45,0x2E,0x45,0x78,0x74,0x2E,0x29,0x01,0x3E,0x10,
-	0x27,0x20,0x73,0x74,0x61,0x6E,0x64,0x73,0x20,0x66,0x6F,0x72,
+	0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x4D,
-	0x20,0x22,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x22,0x20,0x28,
+	0x49,0x44,0x49,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x29,0x2E,
+	0x43,0x30,0x30,0x32,0x28,0x3E,0x27,0x70,0x2E,0x27,0x20,0x73,
-	0x40,0x3E,0x53,0x65,0x76,0x65,0x72,0x61,0x6C,0x20,0x69,0x6E,
+	0x74,0x61,0x6E,0x64,0x73,0x20,0x66,0x6F,0x72,0x20,0x22,0x70,
-	0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x73,0x20,0x63,0x61,
+	0x72,0x6F,0x67,0x72,0x61,0x6D,0x22,0x20,0x28,0x69,0x6E,0x73,
-	0x6E,0x20,0x68,0x61,0x76,0x65,0x20,0x74,0x68,0x65,0x20,0x73,
+	0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x29,0x2E,0x40,0x3E,0x53,
-	0x61,0x6D,0x65,0x20,0x74,0x72,0x61,0x6E,0x73,0x6D,0x69,0x74,
+	0x65,0x76,0x65,0x72,0x61,0x6C,0x20,0x69,0x6E,0x73,0x74,0x72,
-	0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x20,0x62,0x75,0x74,
+	0x75,0x6D,0x65,0x6E,0x74,0x73,0x20,0x63,0x61,0x6E,0x20,0x68,
-	0x20,0x77,0x69,0x74,0x68,0x33,0x64,0x69,0x66,0x66,0x65,0x72,
+	0x61,0x76,0x65,0x20,0x74,0x68,0x65,0x20,0x73,0x61,0x6D,0x65,
-	0x65,0x6E,0x74,0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x73,
+	0x20,0x74,0x72,0x61,0x6E,0x73,0x6D,0x69,0x74,0x20,0x63,0x68,
-	0x2E,0x20,0x46,0x54,0x32,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,
+	0x61,0x6E,0x6E,0x65,0x6C,0x20,0x62,0x75,0x74,0x20,0x77,0x69,
-	0x73,0x20,0x74,0x68,0x65,0x20,0x70,0x72,0x6F,0x67,0x72,0x61,
+	0x74,0x68,0x33,0x64,0x69,0x66,0x66,0x65,0x72,0x65,0x6E,0x74,
-	0x6D,0x73,0x20,0x6F,0x6E,0x20,0x74,0x68,0x65,0x43,0x4D,0x49,
+	0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x73,0x2E,0x20,0x46,
-	0x44,0x49,0x2D,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x73,0x20,
+	0x54,0x32,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x73,0x20,0x74,
-	0x69,0x6E,0x73,0x74,0x61,0x6E,0x74,0x6C,0x79,0x20,0x64,0x75,
+	0x68,0x65,0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x73,0x20,
-	0x72,0x69,0x6E,0x67,0x20,0x70,0x6C,0x61,0x79,0x20,0x69,0x66,
+	0x6F,0x6E,0x20,0x74,0x68,0x65,0x43,0x4D,0x49,0x44,0x49,0x2D,
-	0x20,0x64,0x69,0x66,0x66,0x65,0x72,0x65,0x6E,0x74,0x20,0x70,
+	0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x73,0x20,0x69,0x6E,0x73,
-	0x72,0x6F,0x67,0x72,0x61,0x6D,0x73,0x20,0x61,0x72,0x65,0x20,
+	0x74,0x61,0x6E,0x74,0x6C,0x79,0x20,0x64,0x75,0x72,0x69,0x6E,
-	0x75,0x73,0x65,0x64,0x2E,0x3E,0x44,0x69,0x66,0x66,0x65,0x72,
+	0x67,0x20,0x70,0x6C,0x61,0x79,0x20,0x69,0x66,0x20,0x64,0x69,
-	0x65,0x6E,0x74,0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x73,
+	0x66,0x66,0x65,0x72,0x65,0x6E,0x74,0x20,0x70,0x72,0x6F,0x67,
-	0x20,0x63,0x61,0x6E,0x6E,0x6F,0x74,0x20,0x62,0x65,0x20,0x70,
+	0x72,0x61,0x6D,0x73,0x20,0x61,0x72,0x65,0x20,0x75,0x73,0x65,
-	0x6C,0x61,0x79,0x65,0x64,0x20,0x61,0x74,0x20,0x74,0x68,0x65,
+	0x64,0x2E,0x3E,0x44,0x69,0x66,0x66,0x65,0x72,0x65,0x6E,0x74,
-	0x20,0x73,0x61,0x6D,0x65,0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,
+	0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x73,0x20,0x63,0x61,
-	0x6C,0x20,0x61,0x74,0x20,0x74,0x68,0x65,0x11,0x73,0x61,0x6D,
+	0x6E,0x6E,0x6F,0x74,0x20,0x62,0x65,0x20,0x70,0x6C,0x61,0x79,
-	0x65,0x20,0x74,0x69,0x6D,0x65,0x20,0x74,0x68,0x6F,0x75,0x67,
+	0x65,0x64,0x20,0x61,0x74,0x20,0x74,0x68,0x65,0x20,0x73,0x61,
-	0x68,0x2E,0x44,0x3E,0x49,0x66,0x20,0x79,0x6F,0x75,0x20,0x63,
+	0x6D,0x65,0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x20,0x61,
-	0x68,0x61,0x6E,0x67,0x65,0x20,0x74,0x68,0x69,0x73,0x20,0x76,
+	0x74,0x20,0x74,0x68,0x65,0x11,0x73,0x61,0x6D,0x65,0x20,0x74,
-	0x61,0x6C,0x75,0x65,0x2C,0x20,0x74,0x68,0x65,0x20,0x70,0x72,
+	0x69,0x6D,0x65,0x20,0x74,0x68,0x6F,0x75,0x67,0x68,0x2E,0x44,
-	0x6F,0x67,0x72,0x61,0x6D,0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,
+	0x3E,0x49,0x66,0x20,0x79,0x6F,0x75,0x20,0x63,0x68,0x61,0x6E,
-	0x20,0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x74,0x72,0x61,
+	0x67,0x65,0x20,0x74,0x68,0x69,0x73,0x20,0x76,0x61,0x6C,0x75,
-	0x6E,0x73,0x6D,0x69,0x74,0x74,0x65,0x64,0x20,0x74,0x6F,0x1C,
+	0x65,0x2C,0x20,0x74,0x68,0x65,0x20,0x70,0x72,0x6F,0x67,0x72,
-	0x74,0x68,0x65,0x20,0x73,0x79,0x6E,0x74,0x68,0x65,0x73,0x69,
+	0x61,0x6D,0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x20,0x77,0x69,
-	0x7A,0x65,0x72,0x20,0x69,0x6D,0x6D,0x65,0x64,0x69,0x61,0x74,
+	0x6C,0x6C,0x20,0x62,0x65,0x20,0x74,0x72,0x61,0x6E,0x73,0x6D,
-	0x65,0x6C,0x79,0x2E,0x3E,0x3E,0x53,0x6F,0x6D,0x65,0x20,0x73,
+	0x69,0x74,0x74,0x65,0x64,0x20,0x74,0x6F,0x1C,0x74,0x68,0x65,
-	0x79,0x6E,0x74,0x68,0x65,0x73,0x69,0x7A,0x65,0x72,0x73,0x20,
+	0x20,0x73,0x79,0x6E,0x74,0x68,0x65,0x73,0x69,0x7A,0x65,0x72,
-	0x74,0x72,0x61,0x6E,0x73,0x6D,0x69,0x74,0x20,0x70,0x72,0x6F,
+	0x20,0x69,0x6D,0x6D,0x65,0x64,0x69,0x61,0x74,0x65,0x6C,0x79,
-	0x67,0x72,0x61,0x6D,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x20,
+	0x2E,0x3E,0x3E,0x53,0x6F,0x6D,0x65,0x20,0x73,0x79,0x6E,0x74,
-	0x69,0x6E,0x66,0x6F,0x72,0x6D,0x61,0x74,0x69,0x6F,0x6E,0x2E,
+	0x68,0x65,0x73,0x69,0x7A,0x65,0x72,0x73,0x20,0x74,0x72,0x61,
-	0x20,0x49,0x66,0x20,0x74,0x68,0x65,0x43,0x63,0x75,0x72,0x72,
+	0x6E,0x73,0x6D,0x69,0x74,0x20,0x70,0x72,0x6F,0x67,0x72,0x61,
-	0x65,0x6E,0x74,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,
+	0x6D,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x20,0x69,0x6E,0x66,
-	0x6E,0x74,0x20,0x69,0x6E,0x20,0x46,0x54,0x32,0x20,0x69,0x73,
+	0x6F,0x72,0x6D,0x61,0x74,0x69,0x6F,0x6E,0x2E,0x20,0x49,0x66,
-	0x20,0x61,0x20,0x4D,0x49,0x44,0x49,0x2D,0x69,0x6E,0x73,0x74,
+	0x20,0x74,0x68,0x65,0x43,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,
-	0x72,0x2E,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65,0x20,
+	0x20,0x69,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,
-	0x73,0x61,0x6D,0x65,0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,
+	0x69,0x6E,0x20,0x46,0x54,0x32,0x20,0x69,0x73,0x20,0x61,0x20,
-	0x20,0x61,0x73,0x3F,0x74,0x68,0x65,0x20,0x72,0x65,0x63,0x65,
+	0x4D,0x49,0x44,0x49,0x2D,0x69,0x6E,0x73,0x74,0x72,0x2E,0x20,
-	0x69,0x76,0x65,0x64,0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,
+	0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65,0x20,0x73,0x61,0x6D,
-	0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x2C,0x20,0x69,0x74,0x27,
+	0x65,0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x20,0x61,0x73,
-	0x73,0x20,0x4D,0x49,0x44,0x49,0x2D,0x70,0x72,0x6F,0x67,0x72,
+	0x3F,0x74,0x68,0x65,0x20,0x72,0x65,0x63,0x65,0x69,0x76,0x65,
-	0x61,0x6D,0x20,0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x63,
+	0x64,0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x20,0x63,0x68,
-	0x68,0x61,0x6E,0x67,0x65,0x64,0x2E,0x40,0x3E,0x49,0x66,0x20,
+	0x61,0x6E,0x67,0x65,0x2C,0x20,0x69,0x74,0x27,0x73,0x20,0x4D,
-	0x79,0x6F,0x75,0x72,0x20,0x73,0x79,0x6E,0x74,0x68,0x65,0x73,
+	0x49,0x44,0x49,0x2D,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x20,
-	0x69,0x7A,0x65,0x72,0x20,0x64,0x6F,0x65,0x73,0x6E,0x27,0x74,
+	0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x63,0x68,0x61,0x6E,
-	0x20,0x74,0x72,0x61,0x6E,0x73,0x6D,0x69,0x74,0x20,0x70,0x72,
+	0x67,0x65,0x64,0x2E,0x40,0x3E,0x49,0x66,0x20,0x79,0x6F,0x75,
-	0x6F,0x67,0x72,0x61,0x6D,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,
+	0x72,0x20,0x73,0x79,0x6E,0x74,0x68,0x65,0x73,0x69,0x7A,0x65,
-	0x2C,0x20,0x74,0x68,0x65,0x72,0x65,0x27,0x73,0x20,0x6E,0x6F,
+	0x72,0x20,0x64,0x6F,0x65,0x73,0x6E,0x27,0x74,0x20,0x74,0x72,
-	0x3E,0x70,0x6F,0x69,0x6E,0x74,0x20,0x69,0x6E,0x20,0x63,0x68,
+	0x61,0x6E,0x73,0x6D,0x69,0x74,0x20,0x70,0x72,0x6F,0x67,0x72,
-	0x61,0x6E,0x67,0x69,0x6E,0x67,0x20,0x69,0x74,0x20,0x6F,0x6E,
+	0x61,0x6D,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x2C,0x20,0x74,
-	0x20,0x74,0x68,0x65,0x20,0x73,0x79,0x6E,0x74,0x68,0x65,0x73,
+	0x68,0x65,0x72,0x65,0x27,0x73,0x20,0x6E,0x6F,0x3E,0x70,0x6F,
-	0x69,0x7A,0x65,0x72,0x2C,0x20,0x64,0x6F,0x20,0x69,0x74,0x20,
+	0x69,0x6E,0x74,0x20,0x69,0x6E,0x20,0x63,0x68,0x61,0x6E,0x67,
-	0x69,0x6E,0x20,0x46,0x54,0x32,0x20,0x69,0x6E,0x73,0x74,0x65,
+	0x69,0x6E,0x67,0x20,0x69,0x74,0x20,0x6F,0x6E,0x20,0x74,0x68,
-	0x61,0x64,0x2E,0x00,0x18,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,
+	0x65,0x20,0x73,0x79,0x6E,0x74,0x68,0x65,0x73,0x69,0x7A,0x65,
-	0x43,0x30,0x30,0x31,0x42,0x65,0x6E,0x64,0x65,0x72,0x20,0x72,
+	0x72,0x2C,0x20,0x64,0x6F,0x20,0x69,0x74,0x20,0x69,0x6E,0x20,
-	0x61,0x6E,0x67,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,
+	0x46,0x54,0x32,0x20,0x69,0x6E,0x73,0x74,0x65,0x61,0x64,0x2E,
-	0x40,0x43,0x30,0x30,0x32,0x38,0x3E,0x54,0x68,0x69,0x73,0x20,
+	0x00,0x18,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
-	0x76,0x61,0x6C,0x75,0x65,0x20,0x64,0x65,0x66,0x69,0x6E,0x65,
+	0x31,0x42,0x65,0x6E,0x64,0x65,0x72,0x20,0x72,0x61,0x6E,0x67,
-	0x73,0x20,0x68,0x6F,0x77,0x20,0x6D,0x61,0x6E,0x79,0x20,0x6E,
+	0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
-	0x6F,0x74,0x65,0x73,0x20,0x74,0x68,0x65,0x20,0x69,0x6E,0x73,
+	0x30,0x32,0x38,0x3E,0x54,0x68,0x69,0x73,0x20,0x76,0x61,0x6C,
-	0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x20,0x6F,0x6E,0x20,0x74,
+	0x75,0x65,0x20,0x64,0x65,0x66,0x69,0x6E,0x65,0x73,0x20,0x68,
-	0x68,0x65,0x37,0x73,0x79,0x6E,0x74,0x68,0x65,0x73,0x69,0x7A,
+	0x6F,0x77,0x20,0x6D,0x61,0x6E,0x79,0x20,0x6E,0x6F,0x74,0x65,
-	0x65,0x72,0x20,0x63,0x61,0x6E,0x20,0x62,0x65,0x20,0x70,0x69,
+	0x73,0x20,0x74,0x68,0x65,0x20,0x69,0x6E,0x73,0x74,0x72,0x75,
-	0x74,0x63,0x68,0x62,0x65,0x6E,0x64,0x65,0x64,0x2E,0x20,0x46,
+	0x6D,0x65,0x6E,0x74,0x20,0x6F,0x6E,0x20,0x74,0x68,0x65,0x37,
-	0x54,0x32,0x20,0x75,0x73,0x65,0x73,0x20,0x74,0x68,0x69,0x73,
+	0x73,0x79,0x6E,0x74,0x68,0x65,0x73,0x69,0x7A,0x65,0x72,0x20,
-	0x20,0x76,0x61,0x6C,0x75,0x65,0x20,0x66,0x6F,0x72,0x37,0x74,
+	0x63,0x61,0x6E,0x20,0x62,0x65,0x20,0x70,0x69,0x74,0x63,0x68,
-	0x72,0x61,0x6E,0x73,0x6D,0x69,0x74,0x74,0x69,0x6E,0x67,0x20,
+	0x62,0x65,0x6E,0x64,0x65,0x64,0x2E,0x20,0x46,0x54,0x32,0x20,
-	0x74,0x68,0x65,0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,
+	0x75,0x73,0x65,0x73,0x20,0x74,0x68,0x69,0x73,0x20,0x76,0x61,
-	0x74,0x6F,0x20,0x75,0x70,0x2F,0x64,0x6F,0x77,0x6E,0x20,0x61,
+	0x6C,0x75,0x65,0x20,0x66,0x6F,0x72,0x37,0x74,0x72,0x61,0x6E,
-	0x6E,0x64,0x20,0x74,0x6F,0x6E,0x65,0x2D,0x70,0x6F,0x72,0x74,
+	0x73,0x6D,0x69,0x74,0x74,0x69,0x6E,0x67,0x20,0x74,0x68,0x65,
-	0x61,0x6D,0x65,0x6E,0x74,0x6F,0x13,0x63,0x6F,0x6D,0x6D,0x61,
+	0x20,0x70,0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x20,
-	0x6E,0x64,0x73,0x20,0x63,0x6F,0x72,0x72,0x65,0x63,0x74,0x6C,
+	0x75,0x70,0x2F,0x64,0x6F,0x77,0x6E,0x20,0x61,0x6E,0x64,0x20,
-	0x79,0x2E,0x45,0x3E,0x54,0x68,0x65,0x20,0x4D,0x49,0x44,0x49,
+	0x74,0x6F,0x6E,0x65,0x2D,0x70,0x6F,0x72,0x74,0x61,0x6D,0x65,
-	0x2D,0x70,0x69,0x74,0x63,0x68,0x62,0x65,0x6E,0x64,0x20,0x77,
+	0x6E,0x74,0x6F,0x13,0x63,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x73,
-	0x6F,0x72,0x6B,0x73,0x20,0x63,0x6F,0x72,0x72,0x65,0x63,0x74,
+	0x20,0x63,0x6F,0x72,0x72,0x65,0x63,0x74,0x6C,0x79,0x2E,0x45,
-	0x6C,0x79,0x20,0x6F,0x6E,0x6C,0x79,0x20,0x77,0x69,0x74,0x68,
+	0x3E,0x54,0x68,0x65,0x20,0x4D,0x49,0x44,0x49,0x2D,0x70,0x69,
-	0x20,0x6C,0x69,0x6E,0x65,0x61,0x72,0x20,0x66,0x72,0x65,0x71,
+	0x74,0x63,0x68,0x62,0x65,0x6E,0x64,0x20,0x77,0x6F,0x72,0x6B,
-	0x75,0x65,0x6E,0x63,0x79,0x20,0x74,0x61,0x62,0x6C,0x65,0x2E,
+	0x73,0x20,0x63,0x6F,0x72,0x72,0x65,0x63,0x74,0x6C,0x79,0x20,
-	0x00,0x18,0x40,0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x31,
+	0x6F,0x6E,0x6C,0x79,0x20,0x77,0x69,0x74,0x68,0x20,0x6C,0x69,
-	0x53,0x61,0x6D,0x70,0x6C,0x65,0x20,0x45,0x64,0x69,0x74,0x6F,
+	0x6E,0x65,0x61,0x72,0x20,0x66,0x72,0x65,0x71,0x75,0x65,0x6E,
-	0x72,0x3A,0x01,0x3E,0x2C,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,
+	0x63,0x79,0x20,0x74,0x61,0x62,0x6C,0x65,0x2E,0x00,0x18,0x40,
-	0x43,0x30,0x30,0x31,0x50,0x6C,0x61,0x79,0x20,0x28,0x57,0x61,
+	0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x61,0x6D,
-	0x76,0x65,0x20,0x66,0x6F,0x72,0x6D,0x2C,0x20,0x72,0x61,0x6E,
+	0x70,0x6C,0x65,0x20,0x45,0x64,0x69,0x74,0x6F,0x72,0x3A,0x01,
-	0x67,0x65,0x2C,0x20,0x64,0x69,0x73,0x70,0x6C,0x61,0x79,0x29,
+	0x3E,0x2C,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
-	0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,
+	0x31,0x50,0x6C,0x61,0x79,0x20,0x28,0x57,0x61,0x76,0x65,0x20,
-	0x32,0x3C,0x3E,0x50,0x6C,0x61,0x79,0x73,0x20,0x74,0x68,0x65,
+	0x66,0x6F,0x72,0x6D,0x2C,0x20,0x72,0x61,0x6E,0x67,0x65,0x2C,
-	0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x73,0x61,0x6D,
+	0x20,0x64,0x69,0x73,0x70,0x6C,0x61,0x79,0x29,0x3A,0x0B,0x3E,
-	0x70,0x6C,0x65,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x6F,0x6E,
+	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3C,0x3E,
-	0x65,0x20,0x64,0x69,0x73,0x70,0x6C,0x61,0x79,0x20,0x61,0x62,
+	0x50,0x6C,0x61,0x79,0x73,0x20,0x74,0x68,0x65,0x20,0x63,0x75,
-	0x6F,0x76,0x65,0x20,0x74,0x68,0x65,0x20,0x22,0x73,0x74,0x6F,
+	0x72,0x72,0x65,0x6E,0x74,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,
-	0x70,0x22,0x3D,0x62,0x75,0x74,0x74,0x6F,0x6E,0x2E,0x20,0x4E,
+	0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x6F,0x6E,0x65,0x20,0x64,
-	0x6F,0x74,0x65,0x20,0x74,0x68,0x61,0x74,0x20,0x72,0x65,0x73,
+	0x69,0x73,0x70,0x6C,0x61,0x79,0x20,0x61,0x62,0x6F,0x76,0x65,
-	0x70,0x65,0x63,0x74,0x20,0x69,0x73,0x20,0x74,0x61,0x6B,0x65,
+	0x20,0x74,0x68,0x65,0x20,0x22,0x73,0x74,0x6F,0x70,0x22,0x3D,
-	0x6E,0x20,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x72,
+	0x62,0x75,0x74,0x74,0x6F,0x6E,0x2E,0x20,0x4E,0x6F,0x74,0x65,
-	0x74,0x69,0x63,0x75,0x6C,0x61,0x72,0x20,0x73,0x61,0x6D,0x70,
+	0x20,0x74,0x68,0x61,0x74,0x20,0x72,0x65,0x73,0x70,0x65,0x63,
-	0x6C,0x65,0x27,0x73,0x0E,0x72,0x65,0x6C,0x61,0x74,0x69,0x76,
+	0x74,0x20,0x69,0x73,0x20,0x74,0x61,0x6B,0x65,0x6E,0x20,0x74,
-	0x65,0x20,0x74,0x6F,0x6E,0x65,0x2E,0x00,0x16,0x3E,0x40,0x58,
+	0x6F,0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x72,0x74,0x69,0x63,
-	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x61,0x76,0x65,
+	0x75,0x6C,0x61,0x72,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x27,
-	0x20,0x72,0x61,0x6E,0x67,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,
+	0x73,0x0E,0x72,0x65,0x6C,0x61,0x74,0x69,0x76,0x65,0x20,0x74,
-	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3C,0x3E,0x53,0x74,0x6F,
+	0x6F,0x6E,0x65,0x2E,0x00,0x16,0x3E,0x40,0x58,0x30,0x34,0x30,
-	0x72,0x65,0x73,0x20,0x74,0x68,0x65,0x20,0x72,0x61,0x6E,0x67,
+	0x40,0x43,0x30,0x30,0x31,0x53,0x61,0x76,0x65,0x20,0x72,0x61,
-	0x65,0x20,0x73,0x70,0x65,0x63,0x69,0x66,0x69,0x65,0x64,0x20,
+	0x6E,0x67,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x63,0x75,0x72,0x72,0x65,
+	0x43,0x30,0x30,0x32,0x3C,0x3E,0x53,0x74,0x6F,0x72,0x65,0x73,
-	0x6E,0x74,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x64,0x69,
+	0x20,0x74,0x68,0x65,0x20,0x72,0x61,0x6E,0x67,0x65,0x20,0x73,
-	0x72,0x65,0x63,0x74,0x6F,0x72,0x79,0x2E,0x00,0x11,0x3E,0x40,
+	0x70,0x65,0x63,0x69,0x66,0x69,0x65,0x64,0x20,0x69,0x6E,0x20,
-	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x50,0x61,0x73,
+	0x74,0x68,0x65,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,
-	0x74,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
+	0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x64,0x69,0x72,0x65,0x63,
-	0x30,0x30,0x32,0x40,0x3E,0x54,0x68,0x65,0x20,0x73,0x61,0x6D,
+	0x74,0x6F,0x72,0x79,0x2E,0x00,0x11,0x3E,0x40,0x58,0x30,0x34,
-	0x70,0x6C,0x65,0x20,0x64,0x61,0x74,0x61,0x20,0x69,0x6E,0x20,
+	0x30,0x40,0x43,0x30,0x30,0x31,0x50,0x61,0x73,0x74,0x65,0x3A,
-	0x74,0x68,0x65,0x20,0x63,0x6F,0x70,0x79,0x20,0x62,0x75,0x66,
+	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
-	0x66,0x65,0x72,0x20,0x69,0x73,0x20,0x73,0x74,0x6F,0x72,0x65,
+	0x40,0x3E,0x54,0x68,0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,
-	0x64,0x20,0x49,0x4E,0x54,0x4F,0x20,0x74,0x68,0x65,0x20,0x73,
+	0x20,0x64,0x61,0x74,0x61,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,
-	0x70,0x65,0x63,0x69,0x66,0x69,0x65,0x64,0x06,0x72,0x61,0x6E,
+	0x20,0x63,0x6F,0x70,0x79,0x20,0x62,0x75,0x66,0x66,0x65,0x72,
-	0x67,0x65,0x2E,0x00,0x10,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,
+	0x20,0x69,0x73,0x20,0x73,0x74,0x6F,0x72,0x65,0x64,0x20,0x49,
-	0x43,0x30,0x30,0x31,0x43,0x72,0x6F,0x70,0x3A,0x0B,0x3E,0x40,
+	0x4E,0x54,0x4F,0x20,0x74,0x68,0x65,0x20,0x73,0x70,0x65,0x63,
-	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3E,0x3E,0x43,
+	0x69,0x66,0x69,0x65,0x64,0x06,0x72,0x61,0x6E,0x67,0x65,0x2E,
-	0x75,0x74,0x73,0x20,0x65,0x76,0x65,0x72,0x79,0x74,0x68,0x69,
+	0x00,0x10,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
-	0x6E,0x67,0x20,0x62,0x75,0x74,0x20,0x74,0x68,0x65,0x20,0x72,
+	0x31,0x43,0x72,0x6F,0x70,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,
-	0x61,0x6E,0x67,0x65,0x2E,0x20,0x4E,0x6F,0x74,0x68,0x69,0x6E,
+	0x30,0x40,0x43,0x30,0x30,0x32,0x3E,0x3E,0x43,0x75,0x74,0x73,
-	0x67,0x20,0x69,0x73,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x64,
+	0x20,0x65,0x76,0x65,0x72,0x79,0x74,0x68,0x69,0x6E,0x67,0x20,
-	0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x63,0x6F,0x70,0x79,
+	0x62,0x75,0x74,0x20,0x74,0x68,0x65,0x20,0x72,0x61,0x6E,0x67,
-	0x19,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x62,0x79,0x20,0x74,
+	0x65,0x2E,0x20,0x4E,0x6F,0x74,0x68,0x69,0x6E,0x67,0x20,0x69,
-	0x68,0x69,0x73,0x20,0x6F,0x70,0x65,0x72,0x61,0x74,0x69,0x6F,
+	0x73,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,0x64,0x20,0x69,0x6E,
-	0x6E,0x2E,0x00,0x12,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,
+	0x20,0x74,0x68,0x65,0x20,0x63,0x6F,0x70,0x79,0x19,0x62,0x75,
-	0x30,0x30,0x31,0x56,0x6F,0x6C,0x75,0x6D,0x65,0x3A,0x0B,0x3E,
+	0x66,0x66,0x65,0x72,0x20,0x62,0x79,0x20,0x74,0x68,0x69,0x73,
-	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x17,0x3E,
+	0x20,0x6F,0x70,0x65,0x72,0x61,0x74,0x69,0x6F,0x6E,0x2E,0x00,
-	0x4F,0x70,0x65,0x72,0x61,0x74,0x65,0x73,0x20,0x6F,0x6E,0x20,
+	0x12,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
-	0x74,0x68,0x65,0x20,0x72,0x61,0x6E,0x67,0x65,0x2E,0x00,0x12,
+	0x56,0x6F,0x6C,0x75,0x6D,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,
-	0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x58,
+	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x17,0x3E,0x4F,0x70,0x65,
-	0x2D,0x46,0x61,0x64,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,
+	0x72,0x61,0x74,0x65,0x73,0x20,0x6F,0x6E,0x20,0x74,0x68,0x65,
+	0x20,0x72,0x61,0x6E,0x67,0x65,0x2E,0x00,0x12,0x3E,0x40,0x58,
+	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x58,0x2D,0x46,0x61,
+	0x64,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
+	0x30,0x30,0x32,0x44,0x3E,0x54,0x68,0x69,0x73,0x20,0x69,0x73,
+	0x20,0x61,0x20,0x74,0x6F,0x6F,0x6C,0x20,0x66,0x6F,0x72,0x20,
+	0x6D,0x61,0x6B,0x69,0x6E,0x67,0x20,0x73,0x6D,0x6F,0x6F,0x74,
+	0x68,0x20,0x6C,0x6F,0x6F,0x70,0x73,0x2E,0x20,0x53,0x70,0x65,
+	0x63,0x69,0x66,0x79,0x20,0x61,0x20,0x72,0x61,0x6E,0x67,0x65,
+	0x20,0x74,0x68,0x61,0x74,0x20,0x63,0x6F,0x76,0x65,0x72,0x73,
+	0x41,0x74,0x68,0x65,0x20,0x66,0x69,0x72,0x73,0x74,0x20,0x6C,
+	0x6F,0x6F,0x70,0x20,0x70,0x6F,0x69,0x6E,0x74,0x2E,0x20,0x4D,
+	0x61,0x6B,0x65,0x20,0x73,0x75,0x72,0x65,0x20,0x74,0x68,0x61,
+	0x74,0x20,0x74,0x68,0x65,0x72,0x65,0x20,0x69,0x73,0x20,0x61,
+	0x73,0x20,0x6D,0x75,0x63,0x68,0x20,0x73,0x70,0x61,0x63,0x65,
+	0x20,0x61,0x66,0x74,0x65,0x72,0x41,0x74,0x68,0x65,0x20,0x73,
+	0x65,0x63,0x6F,0x6E,0x64,0x20,0x6C,0x6F,0x6F,0x70,0x20,0x70,
+	0x6F,0x69,0x6E,0x74,0x20,0x61,0x73,0x20,0x74,0x68,0x65,0x20,
+	0x72,0x61,0x6E,0x67,0x65,0x20,0x62,0x79,0x70,0x61,0x73,0x73,
+	0x65,0x73,0x20,0x74,0x68,0x65,0x20,0x66,0x69,0x72,0x73,0x74,
+	0x20,0x6C,0x6F,0x6F,0x70,0x20,0x70,0x6F,0x69,0x6E,0x74,0x2E,
+	0x1F,0x50,0x72,0x65,0x73,0x73,0x20,0x74,0x68,0x65,0x20,0x58,
+	0x2D,0x66,0x61,0x64,0x65,0x20,0x62,0x75,0x74,0x74,0x6F,0x6E,
+	0x2E,0x20,0x45,0x6E,0x6A,0x6F,0x79,0x21,0x00,0x18,0x3E,0x40,
+	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x38,0x2D,0x42,
+	0x69,0x74,0x2F,0x31,0x36,0x2D,0x62,0x69,0x74,0x3A,0x0B,0x3E,
+	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x42,0x3E,
+	0x49,0x66,0x20,0x79,0x6F,0x75,0x20,0x6C,0x6F,0x61,0x64,0x20,
+	0x61,0x20,0x31,0x36,0x2D,0x62,0x69,0x74,0x20,0x73,0x61,0x6D,
+	0x70,0x6C,0x65,0x20,0x77,0x69,0x74,0x68,0x6F,0x75,0x74,0x20,
+	0x68,0x65,0x61,0x64,0x65,0x72,0x2C,0x20,0x46,0x54,0x32,0x20,
+	0x61,0x73,0x73,0x75,0x6D,0x65,0x73,0x20,0x74,0x68,0x61,0x74,
+	0x20,0x69,0x74,0x27,0x73,0x3E,0x61,0x6E,0x20,0x38,0x2D,0x62,
+	0x69,0x74,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x2E,0x20,0x57,
+	0x68,0x65,0x6E,0x20,0x70,0x72,0x65,0x73,0x73,0x69,0x6E,0x67,
+	0x20,0x74,0x68,0x65,0x20,0x31,0x36,0x2D,0x62,0x69,0x74,0x20,
+	0x62,0x75,0x74,0x74,0x6F,0x6E,0x2C,0x20,0x64,0x6F,0x20,0x6E,
+	0x6F,0x74,0x20,0x70,0x72,0x65,0x73,0x73,0x23,0x22,0x63,0x6F,
+	0x6E,0x76,0x65,0x72,0x74,0x22,0x20,0x77,0x68,0x65,0x6E,0x20,
+	0x74,0x68,0x65,0x20,0x72,0x65,0x71,0x75,0x65,0x73,0x74,0x20,
+	0x69,0x73,0x20,0x6D,0x61,0x64,0x65,0x2E,0x00,0x14,0x3E,0x40,
+	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x4D,0x69,0x6E,
+	0x69,0x6D,0x69,0x7A,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,
 	0x30,0x40,0x43,0x30,0x30,0x32,0x44,0x3E,0x54,0x68,0x69,0x73,
-	0x20,0x69,0x73,0x20,0x61,0x20,0x74,0x6F,0x6F,0x6C,0x20,0x66,
+	0x20,0x66,0x75,0x6E,0x63,0x74,0x69,0x6F,0x6E,0x20,0x63,0x75,
-	0x6F,0x72,0x20,0x6D,0x61,0x6B,0x69,0x6E,0x67,0x20,0x73,0x6D,
+	0x74,0x73,0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x72,0x74,0x20,
-	0x6F,0x6F,0x74,0x68,0x20,0x6C,0x6F,0x6F,0x70,0x73,0x2E,0x20,
+	0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,
-	0x53,0x70,0x65,0x63,0x69,0x66,0x79,0x20,0x61,0x20,0x72,0x61,
+	0x65,0x20,0x74,0x68,0x61,0x74,0x20,0x69,0x73,0x20,0x62,0x65,
-	0x6E,0x67,0x65,0x20,0x74,0x68,0x61,0x74,0x20,0x63,0x6F,0x76,
+	0x79,0x6F,0x6E,0x64,0x20,0x74,0x68,0x65,0x20,0x73,0x65,0x63,
-	0x65,0x72,0x73,0x41,0x74,0x68,0x65,0x20,0x66,0x69,0x72,0x73,
+	0x6F,0x6E,0x64,0x0B,0x6C,0x6F,0x6F,0x70,0x20,0x70,0x6F,0x69,
-	0x74,0x20,0x6C,0x6F,0x6F,0x70,0x20,0x70,0x6F,0x69,0x6E,0x74,
+	0x6E,0x74,0x2E,0x00,0x2D,0x40,0x58,0x30,0x32,0x30,0x40,0x43,
-	0x2E,0x20,0x4D,0x61,0x6B,0x65,0x20,0x73,0x75,0x72,0x65,0x20,
+	0x30,0x30,0x31,0x53,0x61,0x6D,0x70,0x6C,0x65,0x20,0x45,0x64,
-	0x74,0x68,0x61,0x74,0x20,0x74,0x68,0x65,0x72,0x65,0x20,0x69,
+	0x69,0x74,0x6F,0x72,0x20,0x45,0x78,0x74,0x65,0x6E,0x73,0x69,
-	0x73,0x20,0x61,0x73,0x20,0x6D,0x75,0x63,0x68,0x20,0x73,0x70,
+	0x6F,0x6E,0x3A,0x20,0x28,0x53,0x2E,0x45,0x2E,0x45,0x78,0x74,
-	0x61,0x63,0x65,0x20,0x61,0x66,0x74,0x65,0x72,0x41,0x74,0x68,
+	0x2E,0x29,0x01,0x3E,0x27,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,
-	0x65,0x20,0x73,0x65,0x63,0x6F,0x6E,0x64,0x20,0x6C,0x6F,0x6F,
+	0x43,0x30,0x30,0x31,0x43,0x6F,0x70,0x79,0x2F,0x58,0x63,0x68,
-	0x70,0x20,0x70,0x6F,0x69,0x6E,0x74,0x20,0x61,0x73,0x20,0x74,
+	0x67,0x20,0x53,0x61,0x6D,0x70,0x6C,0x65,0x2F,0x49,0x6E,0x73,
-	0x68,0x65,0x20,0x72,0x61,0x6E,0x67,0x65,0x20,0x62,0x79,0x70,
+	0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x3A,0x0B,0x3E,0x40,0x58,
-	0x61,0x73,0x73,0x65,0x73,0x20,0x74,0x68,0x65,0x20,0x66,0x69,
+	0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3C,0x3E,0x54,0x68,
-	0x72,0x73,0x74,0x20,0x6C,0x6F,0x6F,0x70,0x20,0x70,0x6F,0x69,
+	0x65,0x20,0x73,0x6F,0x75,0x72,0x63,0x65,0x20,0x69,0x73,0x20,
-	0x6E,0x74,0x2E,0x1F,0x50,0x72,0x65,0x73,0x73,0x20,0x74,0x68,
+	0x73,0x70,0x65,0x63,0x69,0x66,0x69,0x65,0x64,0x20,0x69,0x6E,
-	0x65,0x20,0x58,0x2D,0x66,0x61,0x64,0x65,0x20,0x62,0x75,0x74,
+	0x20,0x74,0x68,0x65,0x20,0x6C,0x69,0x6E,0x65,0x20,0x6E,0x75,
-	0x74,0x6F,0x6E,0x2E,0x20,0x45,0x6E,0x6A,0x6F,0x79,0x21,0x00,
+	0x6D,0x62,0x65,0x72,0x69,0x6E,0x67,0x20,0x63,0x6F,0x6C,0x75,
-	0x18,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
+	0x6D,0x6E,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x40,0x69,0x6E,
-	0x38,0x2D,0x42,0x69,0x74,0x2F,0x31,0x36,0x2D,0x62,0x69,0x74,
+	0x73,0x74,0x72,0x2E,0x2F,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,
+	0x6C,0x69,0x73,0x74,0x73,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,
+	0x20,0x75,0x70,0x70,0x65,0x72,0x2D,0x72,0x69,0x67,0x68,0x74,
+	0x20,0x63,0x6F,0x72,0x6E,0x65,0x72,0x20,0x6F,0x66,0x20,0x74,
+	0x68,0x65,0x20,0x73,0x63,0x72,0x65,0x65,0x6E,0x2E,0x20,0x54,
+	0x68,0x65,0x29,0x64,0x65,0x73,0x74,0x69,0x6E,0x61,0x74,0x69,
+	0x6F,0x6E,0x20,0x69,0x73,0x20,0x74,0x68,0x65,0x20,0x63,0x75,
+	0x72,0x72,0x65,0x6E,0x74,0x20,0x69,0x6E,0x73,0x74,0x72,0x2E,
+	0x2F,0x73,0x61,0x6D,0x70,0x6C,0x65,0x2E,0x00,0x15,0x3E,0x40,
+	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x42,0x61,0x63,
+	0x6B,0x77,0x61,0x72,0x64,0x73,0x3A,0x0B,0x3E,0x40,0x58,0x30,
+	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x40,0x3E,0x4F,0x70,0x65,
+	0x72,0x61,0x74,0x65,0x73,0x20,0x6F,0x6E,0x20,0x74,0x68,0x65,
+	0x20,0x72,0x61,0x6E,0x67,0x65,0x20,0x28,0x6F,0x72,0x20,0x74,
+	0x68,0x65,0x20,0x77,0x68,0x6F,0x6C,0x65,0x20,0x73,0x61,0x6D,
+	0x70,0x6C,0x65,0x20,0x69,0x66,0x20,0x6E,0x6F,0x20,0x72,0x61,
+	0x6E,0x67,0x65,0x20,0x69,0x73,0x20,0x73,0x65,0x74,0x29,0x2E,
+	0x00,0x13,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
+	0x31,0x43,0x6F,0x6E,0x76,0x65,0x72,0x74,0x3A,0x0B,0x3E,0x40,
+	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x34,0x3E,0x43,
+	0x6F,0x6E,0x76,0x65,0x72,0x74,0x73,0x20,0x74,0x68,0x65,0x20,
+	0x65,0x6E,0x74,0x69,0x72,0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,
+	0x65,0x20,0x66,0x72,0x6F,0x6D,0x2F,0x74,0x6F,0x20,0x73,0x69,
+	0x67,0x6E,0x65,0x64,0x2F,0x75,0x6E,0x73,0x69,0x67,0x6E,0x65,
+	0x64,0x2E,0x00,0x15,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,
+	0x30,0x30,0x31,0x43,0x6F,0x6E,0x76,0x65,0x72,0x74,0x20,0x57,
 	0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,
-	0x32,0x42,0x3E,0x49,0x66,0x20,0x79,0x6F,0x75,0x20,0x6C,0x6F,
+	0x32,0x3F,0x53,0x77,0x61,0x70,0x73,0x20,0x74,0x68,0x65,0x20,
-	0x61,0x64,0x20,0x61,0x20,0x31,0x36,0x2D,0x62,0x69,0x74,0x20,
+	0x62,0x79,0x74,0x65,0x20,0x6F,0x72,0x64,0x65,0x72,0x20,0x74,
-	0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x77,0x69,0x74,0x68,0x6F,
+	0x6F,0x2F,0x66,0x72,0x6F,0x6D,0x20,0x49,0x6E,0x74,0x65,0x6C,
-	0x75,0x74,0x20,0x68,0x65,0x61,0x64,0x65,0x72,0x2C,0x20,0x46,
+	0x20,0x66,0x72,0x6F,0x6D,0x2F,0x74,0x6F,0x20,0x4D,0x6F,0x74,
-	0x54,0x32,0x20,0x61,0x73,0x73,0x75,0x6D,0x65,0x73,0x20,0x74,
+	0x6F,0x72,0x6F,0x6C,0x61,0x20,0x73,0x74,0x61,0x6E,0x64,0x61,
-	0x68,0x61,0x74,0x20,0x69,0x74,0x27,0x73,0x3E,0x61,0x6E,0x20,
+	0x72,0x64,0x20,0x6F,0x6E,0x12,0x74,0x68,0x65,0x20,0x65,0x6E,
-	0x38,0x2D,0x62,0x69,0x74,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,
+	0x74,0x69,0x72,0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x2E,
-	0x2E,0x20,0x57,0x68,0x65,0x6E,0x20,0x70,0x72,0x65,0x73,0x73,
+	0x44,0x59,0x6F,0x75,0x27,0x6C,0x6C,0x20,0x6E,0x65,0x65,0x64,
-	0x69,0x6E,0x67,0x20,0x74,0x68,0x65,0x20,0x31,0x36,0x2D,0x62,
+	0x20,0x74,0x68,0x69,0x73,0x20,0x66,0x75,0x6E,0x63,0x74,0x69,
-	0x69,0x74,0x20,0x62,0x75,0x74,0x74,0x6F,0x6E,0x2C,0x20,0x64,
+	0x6F,0x6E,0x20,0x69,0x66,0x20,0x79,0x6F,0x75,0x20,0x69,0x6D,
-	0x6F,0x20,0x6E,0x6F,0x74,0x20,0x70,0x72,0x65,0x73,0x73,0x23,
+	0x70,0x6F,0x72,0x74,0x20,0x31,0x36,0x2D,0x62,0x69,0x74,0x20,
-	0x22,0x63,0x6F,0x6E,0x76,0x65,0x72,0x74,0x22,0x20,0x77,0x68,
+	0x73,0x61,0x6D,0x70,0x6C,0x65,0x73,0x20,0x77,0x69,0x74,0x68,
-	0x65,0x6E,0x20,0x74,0x68,0x65,0x20,0x72,0x65,0x71,0x75,0x65,
+	0x20,0x4D,0x6F,0x74,0x6F,0x72,0x6F,0x6C,0x61,0x2D,0x62,0x79,
-	0x73,0x74,0x20,0x69,0x73,0x20,0x6D,0x61,0x64,0x65,0x2E,0x00,
+	0x74,0x65,0x2D,0x6F,0x72,0x64,0x65,0x72,0x69,0x6E,0x67,0x20,
-	0x14,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
+	0x28,0x66,0x2E,0x65,0x78,0x2E,0x20,0x4B,0x75,0x72,0x7A,0x77,
-	0x4D,0x69,0x6E,0x69,0x6D,0x69,0x7A,0x65,0x3A,0x0B,0x3E,0x40,
+	0x65,0x69,0x6C,0x20,0x4B,0x32,0x30,0x30,0x30,0x20,0x73,0x61,
-	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x44,0x3E,0x54,
+	0x6D,0x70,0x6C,0x65,0x73,0x2E,0x29,0x00,0x10,0x3E,0x40,0x58,
-	0x68,0x69,0x73,0x20,0x66,0x75,0x6E,0x63,0x74,0x69,0x6F,0x6E,
+	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x45,0x63,0x68,0x6F,
-	0x20,0x63,0x75,0x74,0x73,0x20,0x74,0x68,0x65,0x20,0x70,0x61,
+	0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,
-	0x72,0x74,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x73,0x61,
+	0x32,0x1E,0x4F,0x70,0x65,0x72,0x61,0x74,0x65,0x73,0x20,0x6F,
-	0x6D,0x70,0x6C,0x65,0x20,0x74,0x68,0x61,0x74,0x20,0x69,0x73,
+	0x6E,0x20,0x74,0x68,0x65,0x20,0x65,0x6E,0x74,0x69,0x72,0x65,
-	0x20,0x62,0x65,0x79,0x6F,0x6E,0x64,0x20,0x74,0x68,0x65,0x20,
+	0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x2E,0x00,0x12,0x3E,0x40,
-	0x73,0x65,0x63,0x6F,0x6E,0x64,0x0B,0x6C,0x6F,0x6F,0x70,0x20,
+	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x46,0x69,0x78,
-	0x70,0x6F,0x69,0x6E,0x74,0x2E,0x00,0x2D,0x40,0x58,0x30,0x32,
+	0x20,0x44,0x43,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x61,0x6D,0x70,0x6C,0x65,
+	0x43,0x30,0x30,0x32,0x3D,0x41,0x74,0x74,0x65,0x6D,0x70,0x74,
-	0x20,0x45,0x64,0x69,0x74,0x6F,0x72,0x20,0x45,0x78,0x74,0x65,
+	0x73,0x20,0x74,0x6F,0x20,0x63,0x65,0x6E,0x74,0x65,0x72,0x20,
-	0x6E,0x73,0x69,0x6F,0x6E,0x3A,0x20,0x28,0x53,0x2E,0x45,0x2E,
+	0x61,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x74,0x68,0x61,
-	0x45,0x78,0x74,0x2E,0x29,0x01,0x3E,0x27,0x3E,0x40,0x58,0x30,
+	0x74,0x20,0x68,0x61,0x73,0x20,0x75,0x6E,0x77,0x61,0x6E,0x74,
-	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x43,0x6F,0x70,0x79,0x2F,
+	0x65,0x64,0x20,0x44,0x43,0x20,0x6F,0x66,0x66,0x73,0x65,0x74,
-	0x58,0x63,0x68,0x67,0x20,0x53,0x61,0x6D,0x70,0x6C,0x65,0x2F,
+	0x2F,0x62,0x69,0x61,0x73,0x2E,0x43,0x50,0x6C,0x65,0x61,0x73,
-	0x49,0x6E,0x73,0x74,0x72,0x75,0x6D,0x65,0x6E,0x74,0x3A,0x0B,
+	0x65,0x20,0x6E,0x6F,0x74,0x65,0x20,0x74,0x68,0x61,0x74,0x20,
+	0x69,0x74,0x20,0x69,0x73,0x20,0x75,0x73,0x69,0x6E,0x67,0x20,
+	0x61,0x20,0x63,0x72,0x75,0x64,0x65,0x20,0x61,0x6C,0x67,0x6F,
+	0x72,0x69,0x74,0x68,0x6D,0x2C,0x20,0x73,0x6F,0x20,0x69,0x74,
+	0x20,0x63,0x61,0x6E,0x20,0x73,0x6F,0x6D,0x65,0x74,0x69,0x6D,
+	0x65,0x73,0x22,0x66,0x61,0x69,0x6C,0x20,0x64,0x65,0x70,0x65,
+	0x6E,0x64,0x69,0x6E,0x67,0x20,0x6F,0x6E,0x20,0x74,0x68,0x65,
+	0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x64,0x61,0x74,0x61,
+	0x2E,0x00,0x14,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
+	0x30,0x31,0x52,0x65,0x73,0x61,0x6D,0x70,0x6C,0x65,0x3A,0x0B,
 	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3C,
-	0x3E,0x54,0x68,0x65,0x20,0x73,0x6F,0x75,0x72,0x63,0x65,0x20,
-	0x69,0x73,0x20,0x73,0x70,0x65,0x63,0x69,0x66,0x69,0x65,0x64,
-	0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x6C,0x69,0x6E,0x65,
-	0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x69,0x6E,0x67,0x20,0x63,
-	0x6F,0x6C,0x75,0x6D,0x6E,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,
-	0x40,0x69,0x6E,0x73,0x74,0x72,0x2E,0x2F,0x73,0x61,0x6D,0x70,
-	0x6C,0x65,0x20,0x6C,0x69,0x73,0x74,0x73,0x20,0x69,0x6E,0x20,
-	0x74,0x68,0x65,0x20,0x75,0x70,0x70,0x65,0x72,0x2D,0x72,0x69,
-	0x67,0x68,0x74,0x20,0x63,0x6F,0x72,0x6E,0x65,0x72,0x20,0x6F,
-	0x66,0x20,0x74,0x68,0x65,0x20,0x73,0x63,0x72,0x65,0x65,0x6E,
-	0x2E,0x20,0x54,0x68,0x65,0x29,0x64,0x65,0x73,0x74,0x69,0x6E,
-	0x61,0x74,0x69,0x6F,0x6E,0x20,0x69,0x73,0x20,0x74,0x68,0x65,
-	0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x69,0x6E,0x73,
-	0x74,0x72,0x2E,0x2F,0x73,0x61,0x6D,0x70,0x6C,0x65,0x2E,0x00,
-	0x15,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
-	0x42,0x61,0x63,0x6B,0x77,0x61,0x72,0x64,0x73,0x3A,0x0B,0x3E,
-	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x40,0x3E,
 	0x4F,0x70,0x65,0x72,0x61,0x74,0x65,0x73,0x20,0x6F,0x6E,0x20,
-	0x74,0x68,0x65,0x20,0x72,0x61,0x6E,0x67,0x65,0x20,0x28,0x6F,
+	0x74,0x68,0x65,0x20,0x65,0x6E,0x74,0x69,0x72,0x65,0x20,0x73,
-	0x72,0x20,0x74,0x68,0x65,0x20,0x77,0x68,0x6F,0x6C,0x65,0x20,
+	0x61,0x6D,0x70,0x6C,0x65,0x2E,0x20,0x54,0x68,0x65,0x20,0x73,
-	0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x69,0x66,0x20,0x6E,0x6F,
+	0x61,0x6D,0x70,0x6C,0x65,0x27,0x73,0x20,0x72,0x65,0x6C,0x61,
-	0x20,0x72,0x61,0x6E,0x67,0x65,0x20,0x69,0x73,0x20,0x73,0x65,
+	0x74,0x69,0x76,0x65,0x20,0x74,0x6F,0x6E,0x65,0x20,0x69,0x73,
-	0x74,0x29,0x2E,0x00,0x13,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,
+	0x2C,0x63,0x68,0x61,0x6E,0x67,0x65,0x64,0x20,0x77,0x69,0x74,
-	0x43,0x30,0x30,0x31,0x43,0x6F,0x6E,0x76,0x65,0x72,0x74,0x3A,
+	0x68,0x20,0x72,0x65,0x73,0x70,0x65,0x63,0x74,0x20,0x74,0x6F,
-	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
+	0x20,0x74,0x68,0x65,0x20,0x72,0x65,0x73,0x61,0x6D,0x70,0x6C,
-	0x34,0x3E,0x43,0x6F,0x6E,0x76,0x65,0x72,0x74,0x73,0x20,0x74,
+	0x69,0x6E,0x67,0x20,0x72,0x61,0x74,0x65,0x2E,0x00,0x16,0x3E,
-	0x68,0x65,0x20,0x65,0x6E,0x74,0x69,0x72,0x65,0x20,0x73,0x61,
+	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x4D,0x69,
-	0x6D,0x70,0x6C,0x65,0x20,0x66,0x72,0x6F,0x6D,0x2F,0x74,0x6F,
+	0x78,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x3A,0x0B,0x3E,0x40,
-	0x20,0x73,0x69,0x67,0x6E,0x65,0x64,0x2F,0x75,0x6E,0x73,0x69,
+	0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x35,0x3E,0x4D,
-	0x67,0x6E,0x65,0x64,0x2E,0x00,0x15,0x3E,0x40,0x58,0x30,0x34,
+	0x69,0x78,0x65,0x73,0x20,0x74,0x68,0x65,0x20,0x73,0x6F,0x75,
-	0x30,0x40,0x43,0x30,0x30,0x31,0x43,0x6F,0x6E,0x76,0x65,0x72,
+	0x72,0x63,0x65,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65,
-	0x74,0x20,0x57,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
+	0x20,0x64,0x65,0x73,0x74,0x69,0x6E,0x61,0x74,0x69,0x6F,0x6E,
-	0x43,0x30,0x30,0x32,0x3F,0x53,0x77,0x61,0x70,0x73,0x20,0x74,
+	0x20,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x73,0x6F,0x75,0x72,
-	0x68,0x65,0x20,0x62,0x79,0x74,0x65,0x20,0x6F,0x72,0x64,0x65,
+	0x63,0x65,0x2E,0x00,0x15,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,
-	0x72,0x20,0x74,0x6F,0x2F,0x66,0x72,0x6F,0x6D,0x20,0x49,0x6E,
+	0x43,0x30,0x30,0x31,0x44,0x72,0x61,0x77,0x20,0x6D,0x6F,0x64,
-	0x74,0x65,0x6C,0x20,0x66,0x72,0x6F,0x6D,0x2F,0x74,0x6F,0x20,
-	0x4D,0x6F,0x74,0x6F,0x72,0x6F,0x6C,0x61,0x20,0x73,0x74,0x61,
-	0x6E,0x64,0x61,0x72,0x64,0x20,0x6F,0x6E,0x12,0x74,0x68,0x65,
-	0x20,0x65,0x6E,0x74,0x69,0x72,0x65,0x20,0x73,0x61,0x6D,0x70,
-	0x6C,0x65,0x2E,0x44,0x59,0x6F,0x75,0x27,0x6C,0x6C,0x20,0x6E,
-	0x65,0x65,0x64,0x20,0x74,0x68,0x69,0x73,0x20,0x66,0x75,0x6E,
-	0x63,0x74,0x69,0x6F,0x6E,0x20,0x69,0x66,0x20,0x79,0x6F,0x75,
-	0x20,0x69,0x6D,0x70,0x6F,0x72,0x74,0x20,0x31,0x36,0x2D,0x62,
-	0x69,0x74,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x73,0x20,0x77,
-	0x69,0x74,0x68,0x20,0x4D,0x6F,0x74,0x6F,0x72,0x6F,0x6C,0x61,
-	0x2D,0x62,0x79,0x74,0x65,0x2D,0x6F,0x72,0x64,0x65,0x72,0x69,
-	0x6E,0x67,0x20,0x28,0x66,0x2E,0x65,0x78,0x2E,0x20,0x4B,0x75,
-	0x72,0x7A,0x77,0x65,0x69,0x6C,0x20,0x4B,0x32,0x30,0x30,0x30,
-	0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x73,0x2E,0x29,0x00,0x10,
-	0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x45,
-	0x63,0x68,0x6F,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x43,0x30,0x30,0x32,0x1E,0x4F,0x70,0x65,0x72,0x61,0x74,0x65,
-	0x73,0x20,0x6F,0x6E,0x20,0x74,0x68,0x65,0x20,0x65,0x6E,0x74,
-	0x69,0x72,0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x2E,0x00,
-	0x12,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
-	0x46,0x69,0x78,0x20,0x44,0x43,0x3A,0x0B,0x3E,0x40,0x58,0x30,
-	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3D,0x41,0x74,0x74,0x65,
-	0x6D,0x70,0x74,0x73,0x20,0x74,0x6F,0x20,0x63,0x65,0x6E,0x74,
-	0x65,0x72,0x20,0x61,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,
-	0x74,0x68,0x61,0x74,0x20,0x68,0x61,0x73,0x20,0x75,0x6E,0x77,
-	0x61,0x6E,0x74,0x65,0x64,0x20,0x44,0x43,0x20,0x6F,0x66,0x66,
-	0x73,0x65,0x74,0x2F,0x62,0x69,0x61,0x73,0x2E,0x43,0x50,0x6C,
-	0x65,0x61,0x73,0x65,0x20,0x6E,0x6F,0x74,0x65,0x20,0x74,0x68,
-	0x61,0x74,0x20,0x69,0x74,0x20,0x69,0x73,0x20,0x75,0x73,0x69,
-	0x6E,0x67,0x20,0x61,0x20,0x63,0x72,0x75,0x64,0x65,0x20,0x61,
-	0x6C,0x67,0x6F,0x72,0x69,0x74,0x68,0x6D,0x2C,0x20,0x73,0x6F,
-	0x20,0x69,0x74,0x20,0x63,0x61,0x6E,0x20,0x73,0x6F,0x6D,0x65,
-	0x74,0x69,0x6D,0x65,0x73,0x22,0x66,0x61,0x69,0x6C,0x20,0x64,
-	0x65,0x70,0x65,0x6E,0x64,0x69,0x6E,0x67,0x20,0x6F,0x6E,0x20,
-	0x74,0x68,0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x64,
-	0x61,0x74,0x61,0x2E,0x00,0x14,0x3E,0x40,0x58,0x30,0x34,0x30,
-	0x40,0x43,0x30,0x30,0x31,0x52,0x65,0x73,0x61,0x6D,0x70,0x6C,
 	0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
-	0x30,0x32,0x3C,0x4F,0x70,0x65,0x72,0x61,0x74,0x65,0x73,0x20,
+	0x30,0x32,0x40,0x42,0x79,0x20,0x70,0x72,0x65,0x73,0x73,0x69,
-	0x6F,0x6E,0x20,0x74,0x68,0x65,0x20,0x65,0x6E,0x74,0x69,0x72,
+	0x6E,0x67,0x20,0x74,0x68,0x65,0x20,0x72,0x69,0x67,0x68,0x74,
-	0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x2E,0x20,0x54,0x68,
+	0x20,0x6D,0x6F,0x75,0x73,0x65,0x20,0x62,0x75,0x74,0x74,0x6F,
-	0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x27,0x73,0x20,0x72,
+	0x6E,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x73,0x61,0x6D,
-	0x65,0x6C,0x61,0x74,0x69,0x76,0x65,0x20,0x74,0x6F,0x6E,0x65,
+	0x70,0x6C,0x65,0x20,0x77,0x69,0x6E,0x64,0x6F,0x77,0x2C,0x20,
-	0x20,0x69,0x73,0x2C,0x63,0x68,0x61,0x6E,0x67,0x65,0x64,0x20,
+	0x79,0x6F,0x75,0x20,0x63,0x61,0x6E,0x1D,0x64,0x72,0x61,0x77,
-	0x77,0x69,0x74,0x68,0x20,0x72,0x65,0x73,0x70,0x65,0x63,0x74,
+	0x20,0x79,0x6F,0x75,0x72,0x20,0x77,0x61,0x76,0x65,0x66,0x6F,
-	0x20,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x72,0x65,0x73,0x61,
+	0x72,0x6D,0x73,0x20,0x6D,0x61,0x6E,0x75,0x61,0x6C,0x6C,0x79,
-	0x6D,0x70,0x6C,0x69,0x6E,0x67,0x20,0x72,0x61,0x74,0x65,0x2E,
+	0x2E,0x00,0x18,0x40,0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,
-	0x00,0x16,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
+	0x31,0x43,0x6F,0x6E,0x66,0x69,0x67,0x75,0x72,0x61,0x74,0x69,
-	0x31,0x4D,0x69,0x78,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x3A,
+	0x6F,0x6E,0x3A,0x01,0x3E,0x15,0x3E,0x40,0x58,0x30,0x34,0x30,
-	0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,
+	0x40,0x43,0x30,0x30,0x31,0x41,0x75,0x74,0x6F,0x20,0x73,0x61,
-	0x35,0x3E,0x4D,0x69,0x78,0x65,0x73,0x20,0x74,0x68,0x65,0x20,
+	0x76,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
-	0x73,0x6F,0x75,0x72,0x63,0x65,0x20,0x77,0x69,0x74,0x68,0x20,
+	0x30,0x30,0x32,0x43,0x49,0x66,0x20,0x74,0x68,0x65,0x20,0x61,
-	0x74,0x68,0x65,0x20,0x64,0x65,0x73,0x74,0x69,0x6E,0x61,0x74,
+	0x75,0x74,0x6F,0x20,0x73,0x61,0x76,0x65,0x20,0x69,0x73,0x20,
-	0x69,0x6F,0x6E,0x20,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x73,
+	0x6F,0x6E,0x2C,0x20,0x46,0x54,0x32,0x20,0x77,0x69,0x6C,0x6C,
-	0x6F,0x75,0x72,0x63,0x65,0x2E,0x00,0x15,0x3E,0x40,0x58,0x30,
+	0x20,0x75,0x70,0x64,0x61,0x74,0x65,0x20,0x74,0x68,0x65,0x20,
-	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x44,0x72,0x61,0x77,0x20,
+	0x63,0x6F,0x6E,0x66,0x69,0x67,0x75,0x72,0x61,0x74,0x69,0x6F,
-	0x6D,0x6F,0x64,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,
+	0x6E,0x20,0x66,0x69,0x6C,0x65,0x20,0x77,0x68,0x65,0x6E,0x15,
-	0x40,0x43,0x30,0x30,0x32,0x40,0x42,0x79,0x20,0x70,0x72,0x65,
+	0x79,0x6F,0x75,0x20,0x65,0x78,0x69,0x74,0x20,0x74,0x68,0x65,
-	0x73,0x73,0x69,0x6E,0x67,0x20,0x74,0x68,0x65,0x20,0x72,0x69,
+	0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x2E,0x00,0x25,0x40,
-	0x67,0x68,0x74,0x20,0x6D,0x6F,0x75,0x73,0x65,0x20,0x62,0x75,
+	0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x31,0x43,0x6F,0x6E,
-	0x74,0x74,0x6F,0x6E,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,
+	0x66,0x69,0x67,0x75,0x72,0x61,0x74,0x69,0x6F,0x6E,0x2C,0x20,
-	0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x77,0x69,0x6E,0x64,0x6F,
+	0x49,0x2F,0x4F,0x20,0x64,0x65,0x76,0x69,0x63,0x65,0x73,0x3A,
-	0x77,0x2C,0x20,0x79,0x6F,0x75,0x20,0x63,0x61,0x6E,0x1D,0x64,
+	0x01,0x3E,0x19,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
-	0x72,0x61,0x77,0x20,0x79,0x6F,0x75,0x72,0x20,0x77,0x61,0x76,
+	0x30,0x31,0x49,0x6E,0x74,0x65,0x72,0x70,0x6F,0x6C,0x61,0x74,
-	0x65,0x66,0x6F,0x72,0x6D,0x73,0x20,0x6D,0x61,0x6E,0x75,0x61,
-	0x6C,0x6C,0x79,0x2E,0x00,0x18,0x40,0x58,0x30,0x32,0x30,0x40,
-	0x43,0x30,0x30,0x31,0x43,0x6F,0x6E,0x66,0x69,0x67,0x75,0x72,
-	0x61,0x74,0x69,0x6F,0x6E,0x3A,0x01,0x3E,0x15,0x3E,0x40,0x58,
-	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x41,0x75,0x74,0x6F,
-	0x20,0x73,0x61,0x76,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,
-	0x30,0x40,0x43,0x30,0x30,0x32,0x43,0x49,0x66,0x20,0x74,0x68,
-	0x65,0x20,0x61,0x75,0x74,0x6F,0x20,0x73,0x61,0x76,0x65,0x20,
-	0x69,0x73,0x20,0x6F,0x6E,0x2C,0x20,0x46,0x54,0x32,0x20,0x77,
-	0x69,0x6C,0x6C,0x20,0x75,0x70,0x64,0x61,0x74,0x65,0x20,0x74,
-	0x68,0x65,0x20,0x63,0x6F,0x6E,0x66,0x69,0x67,0x75,0x72,0x61,
-	0x74,0x69,0x6F,0x6E,0x20,0x66,0x69,0x6C,0x65,0x20,0x77,0x68,
-	0x65,0x6E,0x15,0x79,0x6F,0x75,0x20,0x65,0x78,0x69,0x74,0x20,
-	0x74,0x68,0x65,0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x2E,
-	0x00,0x25,0x40,0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x31,
-	0x43,0x6F,0x6E,0x66,0x69,0x67,0x75,0x72,0x61,0x74,0x69,0x6F,
-	0x6E,0x2C,0x20,0x49,0x2F,0x4F,0x20,0x64,0x65,0x76,0x69,0x63,
-	0x65,0x73,0x3A,0x01,0x3E,0x19,0x3E,0x40,0x58,0x30,0x34,0x30,
-	0x40,0x43,0x30,0x30,0x31,0x49,0x6E,0x74,0x65,0x72,0x70,0x6F,
-	0x6C,0x61,0x74,0x69,0x6F,0x6E,0x3A,0x0B,0x3E,0x40,0x58,0x30,
-	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x35,0x53,0x65,0x6C,0x65,
-	0x63,0x74,0x73,0x20,0x77,0x68,0x61,0x74,0x20,0x74,0x79,0x70,
-	0x65,0x20,0x6F,0x66,0x20,0x72,0x65,0x73,0x61,0x6D,0x70,0x6C,
-	0x69,0x6E,0x67,0x20,0x69,0x6E,0x74,0x65,0x72,0x70,0x6F,0x6C,
-	0x61,0x74,0x69,0x6F,0x6E,0x20,0x74,0x6F,0x20,0x75,0x73,0x65,
-	0x2E,0x45,0x22,0x4E,0x6F,0x6E,0x65,0x22,0x20,0x75,0x73,0x65,
-	0x73,0x20,0x6E,0x6F,0x20,0x69,0x6E,0x74,0x65,0x72,0x70,0x6F,
-	0x6C,0x61,0x74,0x69,0x6F,0x6E,0x20,0x28,0x6E,0x65,0x61,0x72,
-	0x65,0x73,0x74,0x20,0x6E,0x65,0x69,0x67,0x68,0x62,0x6F,0x72,
-	0x29,0x2C,0x20,0x77,0x68,0x69,0x63,0x68,0x20,0x77,0x69,0x6C,
-	0x6C,0x20,0x72,0x65,0x73,0x75,0x6C,0x74,0x20,0x69,0x6E,0x49,
-	0x61,0x6C,0x69,0x61,0x73,0x69,0x6E,0x67,0x20,0x28,0x6E,0x6F,
-	0x69,0x73,0x65,0x29,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,
-	0x73,0x6F,0x75,0x6E,0x64,0x2E,0x20,0x22,0x4C,0x69,0x6E,0x65,
-	0x61,0x72,0x22,0x20,0x69,0x73,0x20,0x77,0x68,0x61,0x74,0x20,
-	0x72,0x65,0x61,0x6C,0x20,0x46,0x54,0x32,0x20,0x75,0x73,0x65,
-	0x73,0x2C,0x20,0x77,0x68,0x69,0x63,0x68,0x20,0x69,0x73,0x20,
-	0x61,0x47,0x6D,0x65,0x64,0x69,0x6F,0x63,0x72,0x65,0x20,0x69,
-	0x6E,0x74,0x65,0x72,0x70,0x6F,0x6C,0x61,0x74,0x69,0x6F,0x6E,
-	0x20,0x74,0x79,0x70,0x65,0x2E,0x20,0x22,0x57,0x69,0x6E,0x64,
-	0x6F,0x77,0x65,0x64,0x2D,0x73,0x69,0x6E,0x63,0x22,0x20,0x69,
-	0x73,0x20,0x74,0x68,0x65,0x20,0x72,0x65,0x63,0x6F,0x6D,0x6D,
-	0x65,0x6E,0x64,0x65,0x64,0x20,0x73,0x65,0x74,0x74,0x69,0x6E,
-	0x67,0x48,0x66,0x6F,0x72,0x20,0x74,0x68,0x65,0x20,0x62,0x65,
-	0x73,0x74,0x20,0x61,0x75,0x64,0x69,0x6F,0x20,0x71,0x75,0x61,
-	0x6C,0x69,0x74,0x79,0x2C,0x20,0x61,0x6C,0x74,0x68,0x6F,0x75,
-	0x67,0x68,0x20,0x69,0x74,0x20,0x6D,0x61,0x79,0x20,0x73,0x6F,
-	0x6D,0x65,0x74,0x69,0x6D,0x65,0x73,0x20,0x73,0x6F,0x75,0x6E,
-	0x64,0x20,0x74,0x6F,0x6F,0x20,0x66,0x69,0x6C,0x74,0x65,0x72,
-	0x65,0x64,0x2A,0x6F,0x6E,0x20,0x6C,0x6F,0x77,0x2D,0x71,0x75,
-	0x61,0x6C,0x69,0x74,0x79,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,
-	0x73,0x20,0x28,0x66,0x2E,0x65,0x78,0x2E,0x20,0x41,0x6D,0x69,
-	0x67,0x61,0x20,0x4D,0x4F,0x44,0x73,0x29,0x2E,0x00,0x1A,0x3E,
-	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x56,0x6F,
-	0x6C,0x75,0x6D,0x65,0x20,0x72,0x61,0x6D,0x70,0x69,0x6E,0x67,
-	0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,
-	0x32,0x3B,0x45,0x6E,0x61,0x62,0x6C,0x65,0x73,0x20,0x74,0x68,
-	0x65,0x20,0x61,0x6E,0x74,0x69,0x2D,0x63,0x6C,0x69,0x63,0x6B,
-	0x20,0x73,0x79,0x73,0x74,0x65,0x6D,0x20,0x69,0x6E,0x20,0x74,
-	0x68,0x65,0x20,0x61,0x75,0x64,0x69,0x6F,0x20,0x6D,0x69,0x78,
-	0x65,0x72,0x20,0x28,0x46,0x54,0x32,0x2E,0x30,0x38,0x2B,0x29,
-	0x2E,0x3B,0x50,0x6C,0x65,0x61,0x73,0x65,0x20,0x6E,0x6F,0x74,
-	0x65,0x20,0x74,0x68,0x61,0x74,0x20,0x6F,0x72,0x69,0x67,0x69,
-	0x6E,0x61,0x6C,0x20,0x46,0x54,0x32,0x20,0x63,0x61,0x6E,0x27,
-	0x74,0x20,0x6C,0x6F,0x61,0x64,0x20,0x74,0x68,0x69,0x73,0x20,
-	0x63,0x6F,0x6E,0x66,0x69,0x67,0x20,0x65,0x6E,0x74,0x72,0x79,
-	0x2C,0x0B,0x63,0x6C,0x6F,0x6E,0x65,0x20,0x6F,0x6E,0x6C,0x79,
-	0x2E,0x00,0x19,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,
-	0x30,0x31,0x41,0x6D,0x70,0x6C,0x69,0x66,0x69,0x63,0x61,0x74,
 	0x69,0x6F,0x6E,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x43,0x30,0x30,0x32,0x46,0x41,0x6D,0x70,0x6C,0x69,0x66,0x69,
+	0x43,0x30,0x30,0x32,0x35,0x53,0x65,0x6C,0x65,0x63,0x74,0x73,
-	0x65,0x73,0x20,0x74,0x68,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,
+	0x20,0x77,0x68,0x61,0x74,0x20,0x74,0x79,0x70,0x65,0x20,0x6F,
-	0x65,0x20,0x77,0x68,0x65,0x6E,0x20,0x6D,0x69,0x78,0x69,0x6E,
+	0x66,0x20,0x72,0x65,0x73,0x61,0x6D,0x70,0x6C,0x69,0x6E,0x67,
-	0x67,0x2E,0x20,0x49,0x66,0x20,0x79,0x6F,0x75,0x20,0x73,0x65,
+	0x20,0x69,0x6E,0x74,0x65,0x72,0x70,0x6F,0x6C,0x61,0x74,0x69,
-	0x74,0x20,0x74,0x68,0x69,0x73,0x20,0x6F,0x6E,0x65,0x20,0x74,
+	0x6F,0x6E,0x20,0x74,0x6F,0x20,0x75,0x73,0x65,0x2E,0x45,0x22,
-	0x6F,0x6F,0x20,0x68,0x69,0x67,0x68,0x2C,0x20,0x79,0x6F,0x75,
+	0x4E,0x6F,0x6E,0x65,0x22,0x20,0x75,0x73,0x65,0x73,0x20,0x6E,
-	0x27,0x6C,0x6C,0x3A,0x67,0x65,0x74,0x20,0x64,0x69,0x73,0x74,
+	0x6F,0x20,0x69,0x6E,0x74,0x65,0x72,0x70,0x6F,0x6C,0x61,0x74,
-	0x6F,0x72,0x74,0x69,0x6F,0x6E,0x2E,0x20,0x33,0x32,0x58,0x20,
+	0x69,0x6F,0x6E,0x20,0x28,0x6E,0x65,0x61,0x72,0x65,0x73,0x74,
-	0x65,0x71,0x75,0x61,0x6C,0x73,0x20,0x66,0x75,0x6C,0x6C,0x20,
+	0x20,0x6E,0x65,0x69,0x67,0x68,0x62,0x6F,0x72,0x29,0x2C,0x20,
-	0x61,0x6D,0x70,0x6C,0x69,0x74,0x75,0x64,0x65,0x20,0x66,0x6F,
+	0x77,0x68,0x69,0x63,0x68,0x20,0x77,0x69,0x6C,0x6C,0x20,0x72,
-	0x72,0x20,0x6F,0x6E,0x65,0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,
+	0x65,0x73,0x75,0x6C,0x74,0x20,0x69,0x6E,0x49,0x61,0x6C,0x69,
-	0x6C,0x2E,0x00,0x1B,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,
+	0x61,0x73,0x69,0x6E,0x67,0x20,0x28,0x6E,0x6F,0x69,0x73,0x65,
-	0x30,0x30,0x31,0x46,0x72,0x65,0x71,0x75,0x65,0x6E,0x63,0x79,
+	0x29,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x73,0x6F,0x75,
-	0x20,0x74,0x61,0x62,0x6C,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,
+	0x6E,0x64,0x2E,0x20,0x22,0x4C,0x69,0x6E,0x65,0x61,0x72,0x22,
-	0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x40,0x54,0x68,0x65,0x20,
+	0x20,0x69,0x73,0x20,0x77,0x68,0x61,0x74,0x20,0x72,0x65,0x61,
-	0x6C,0x69,0x6E,0x65,0x61,0x72,0x20,0x66,0x72,0x65,0x71,0x75,
+	0x6C,0x20,0x46,0x54,0x32,0x20,0x75,0x73,0x65,0x73,0x2C,0x20,
-	0x65,0x6E,0x63,0x79,0x20,0x74,0x61,0x62,0x6C,0x65,0x20,0x6D,
+	0x77,0x68,0x69,0x63,0x68,0x20,0x69,0x73,0x20,0x61,0x47,0x6D,
-	0x61,0x6B,0x65,0x73,0x20,0x61,0x6C,0x6C,0x20,0x70,0x69,0x74,
+	0x65,0x64,0x69,0x6F,0x63,0x72,0x65,0x20,0x69,0x6E,0x74,0x65,
-	0x63,0x68,0x20,0x62,0x65,0x6E,0x64,0x73,0x20,0x72,0x75,0x6E,
+	0x72,0x70,0x6F,0x6C,0x61,0x74,0x69,0x6F,0x6E,0x20,0x74,0x79,
-	0x20,0x69,0x6E,0x20,0x63,0x6F,0x6E,0x73,0x74,0x61,0x6E,0x74,
+	0x70,0x65,0x2E,0x20,0x22,0x57,0x69,0x6E,0x64,0x6F,0x77,0x65,
-	0x3F,0x73,0x70,0x65,0x65,0x64,0x2C,0x20,0x69,0x6E,0x64,0x65,
+	0x64,0x2D,0x73,0x69,0x6E,0x63,0x22,0x20,0x69,0x73,0x20,0x74,
-	0x70,0x65,0x6E,0x64,0x65,0x6E,0x74,0x20,0x6F,0x66,0x20,0x74,
+	0x68,0x65,0x20,0x72,0x65,0x63,0x6F,0x6D,0x6D,0x65,0x6E,0x64,
-	0x68,0x65,0x20,0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x66,
+	0x65,0x64,0x20,0x73,0x65,0x74,0x74,0x69,0x6E,0x67,0x48,0x66,
-	0x72,0x65,0x71,0x75,0x65,0x6E,0x63,0x79,0x2E,0x20,0x49,0x66,
+	0x6F,0x72,0x20,0x74,0x68,0x65,0x20,0x62,0x65,0x73,0x74,0x20,
-	0x20,0x79,0x6F,0x75,0x20,0x73,0x77,0x69,0x74,0x63,0x68,0x20,
+	0x61,0x75,0x64,0x69,0x6F,0x20,0x71,0x75,0x61,0x6C,0x69,0x74,
-	0x74,0x68,0x69,0x73,0x41,0x6F,0x6E,0x65,0x2C,0x20,0x6F,0x6E,
+	0x79,0x2C,0x20,0x61,0x6C,0x74,0x68,0x6F,0x75,0x67,0x68,0x20,
-	0x20,0x61,0x20,0x66,0x69,0x6E,0x69,0x73,0x68,0x65,0x64,0x20,
+	0x69,0x74,0x20,0x6D,0x61,0x79,0x20,0x73,0x6F,0x6D,0x65,0x74,
-	0x73,0x6F,0x6E,0x67,0x2C,0x20,0x69,0x74,0x20,0x6D,0x69,0x67,
+	0x69,0x6D,0x65,0x73,0x20,0x73,0x6F,0x75,0x6E,0x64,0x20,0x74,
-	0x68,0x74,0x20,0x73,0x6F,0x75,0x6E,0x64,0x20,0x73,0x74,0x72,
+	0x6F,0x6F,0x20,0x66,0x69,0x6C,0x74,0x65,0x72,0x65,0x64,0x2A,
-	0x61,0x6E,0x67,0x65,0x20,0x69,0x66,0x20,0x74,0x68,0x65,0x20,
+	0x6F,0x6E,0x20,0x6C,0x6F,0x77,0x2D,0x71,0x75,0x61,0x6C,0x69,
-	0x73,0x6F,0x75,0x6E,0x64,0x20,0x75,0x73,0x65,0x73,0x0D,0x70,
+	0x74,0x79,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x73,0x20,0x28,
-	0x6F,0x72,0x74,0x61,0x6D,0x65,0x6E,0x74,0x6F,0x65,0x73,0x2E,
+	0x66,0x2E,0x65,0x78,0x2E,0x20,0x41,0x6D,0x69,0x67,0x61,0x20,
-	0x00,0x20,0x40,0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x31,
+	0x4D,0x4F,0x44,0x73,0x29,0x2E,0x00,0x1A,0x3E,0x40,0x58,0x30,
-	0x43,0x6F,0x6E,0x66,0x69,0x67,0x75,0x72,0x61,0x74,0x69,0x6F,
+	0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x56,0x6F,0x6C,0x75,0x6D,
-	0x6E,0x2C,0x20,0x4C,0x61,0x79,0x6F,0x75,0x74,0x3A,0x01,0x3E,
+	0x65,0x20,0x72,0x61,0x6D,0x70,0x69,0x6E,0x67,0x3A,0x0B,0x3E,
-	0x29,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
+	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3B,0x45,
-	0x50,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x6C,0x61,0x79,0x6F,
+	0x6E,0x61,0x62,0x6C,0x65,0x73,0x20,0x74,0x68,0x65,0x20,0x61,
-	0x75,0x74,0x2C,0x20,0x68,0x65,0x78,0x20,0x6E,0x75,0x6D,0x62,
+	0x6E,0x74,0x69,0x2D,0x63,0x6C,0x69,0x63,0x6B,0x20,0x73,0x79,
-	0x65,0x72,0x69,0x6E,0x67,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,
+	0x73,0x74,0x65,0x6D,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,
-	0x30,0x40,0x43,0x30,0x30,0x32,0x41,0x49,0x66,0x20,0x79,0x6F,
+	0x61,0x75,0x64,0x69,0x6F,0x20,0x6D,0x69,0x78,0x65,0x72,0x20,
-	0x75,0x20,0x75,0x73,0x65,0x20,0x70,0x61,0x74,0x74,0x65,0x72,
+	0x28,0x46,0x54,0x32,0x2E,0x30,0x38,0x2B,0x29,0x2E,0x3B,0x50,
-	0x6E,0x73,0x20,0x74,0x68,0x61,0x74,0x20,0x61,0x72,0x65,0x20,
+	0x6C,0x65,0x61,0x73,0x65,0x20,0x6E,0x6F,0x74,0x65,0x20,0x74,
-	0x6C,0x6F,0x6E,0x67,0x65,0x72,0x20,0x74,0x68,0x61,0x6E,0x20,
+	0x68,0x61,0x74,0x20,0x6F,0x72,0x69,0x67,0x69,0x6E,0x61,0x6C,
-	0x39,0x39,0x20,0x6C,0x69,0x6E,0x65,0x73,0x2C,0x20,0x79,0x6F,
+	0x20,0x46,0x54,0x32,0x20,0x63,0x61,0x6E,0x27,0x74,0x20,0x6C,
-	0x75,0x20,0x73,0x68,0x6F,0x75,0x6C,0x64,0x20,0x75,0x73,0x65,
+	0x6F,0x61,0x64,0x20,0x74,0x68,0x69,0x73,0x20,0x63,0x6F,0x6E,
-	0x45,0x68,0x65,0x78,0x20,0x63,0x6F,0x75,0x6E,0x74,0x69,0x6E,
+	0x66,0x69,0x67,0x20,0x65,0x6E,0x74,0x72,0x79,0x2C,0x0B,0x63,
-	0x67,0x20,0x73,0x69,0x6E,0x63,0x65,0x20,0x74,0x68,0x65,0x72,
+	0x6C,0x6F,0x6E,0x65,0x20,0x6F,0x6E,0x6C,0x79,0x2E,0x00,0x19,
-	0x65,0x20,0x61,0x72,0x65,0x20,0x6F,0x6E,0x6C,0x79,0x20,0x32,
+	0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x41,
-	0x20,0x64,0x69,0x67,0x69,0x74,0x73,0x20,0x69,0x6E,0x20,0x74,
+	0x6D,0x70,0x6C,0x69,0x66,0x69,0x63,0x61,0x74,0x69,0x6F,0x6E,
-	0x68,0x65,0x20,0x6C,0x69,0x6E,0x65,0x20,0x6E,0x75,0x6D,0x62,
-	0x65,0x72,0x20,0x63,0x6F,0x6C,0x75,0x6D,0x6E,0x2E,0x00,0x12,
-	0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,
-	0x63,0x6F,0x70,0x65,0x73,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,
-	0x30,0x40,0x43,0x30,0x30,0x32,0x43,0x22,0x53,0x74,0x64,0x2E,
-	0x22,0x20,0x28,0x73,0x74,0x61,0x6E,0x64,0x61,0x72,0x64,0x29,
-	0x20,0x77,0x69,0x6C,0x6C,0x20,0x73,0x68,0x6F,0x77,0x20,0x74,
-	0x68,0x65,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x70,0x6F,
-	0x69,0x6E,0x74,0x73,0x20,0x61,0x73,0x20,0x70,0x69,0x78,0x65,
-	0x6C,0x73,0x20,0x28,0x6C,0x69,0x6B,0x65,0x20,0x46,0x54,0x32,
-	0x29,0x2E,0x41,0x22,0x4C,0x69,0x6E,0x65,0x64,0x22,0x20,0x77,
-	0x69,0x6C,0x6C,0x20,0x64,0x72,0x61,0x77,0x20,0x6C,0x69,0x6E,
-	0x65,0x73,0x20,0x62,0x65,0x74,0x77,0x65,0x65,0x6E,0x20,0x74,
-	0x68,0x65,0x20,0x70,0x6F,0x69,0x6E,0x74,0x73,0x2C,0x20,0x6C,
-	0x69,0x6B,0x65,0x20,0x61,0x6E,0x20,0x6F,0x73,0x63,0x69,0x6C,
-	0x6C,0x6F,0x73,0x63,0x6F,0x70,0x65,0x2E,0x00,0x27,0x40,0x58,
-	0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x31,0x43,0x6F,0x6E,0x66,
-	0x69,0x67,0x75,0x72,0x61,0x74,0x69,0x6F,0x6E,0x2C,0x20,0x4D,
-	0x69,0x73,0x63,0x65,0x6C,0x6C,0x61,0x6E,0x65,0x6F,0x75,0x73,
-	0x3A,0x01,0x3E,0x15,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,
-	0x30,0x30,0x31,0x56,0x53,0x79,0x6E,0x63,0x20,0x6F,0x66,0x66,
 	0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,
-	0x32,0x3F,0x54,0x65,0x6C,0x6C,0x73,0x20,0x74,0x68,0x65,0x20,
+	0x32,0x46,0x41,0x6D,0x70,0x6C,0x69,0x66,0x69,0x65,0x73,0x20,
-	0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x20,0x74,0x6F,0x20,0x6E,
+	0x74,0x68,0x65,0x20,0x76,0x6F,0x6C,0x75,0x6D,0x65,0x20,0x77,
-	0x6F,0x74,0x20,0x75,0x73,0x65,0x20,0x56,0x53,0x79,0x6E,0x63,
+	0x68,0x65,0x6E,0x20,0x6D,0x69,0x78,0x69,0x6E,0x67,0x2E,0x20,
-	0x20,0x66,0x6F,0x72,0x20,0x76,0x69,0x64,0x65,0x6F,0x2E,0x20,
+	0x49,0x66,0x20,0x79,0x6F,0x75,0x20,0x73,0x65,0x74,0x20,0x74,
-	0x49,0x66,0x20,0x79,0x6F,0x75,0x72,0x20,0x6D,0x6F,0x6E,0x69,
+	0x68,0x69,0x73,0x20,0x6F,0x6E,0x65,0x20,0x74,0x6F,0x6F,0x20,
-	0x74,0x6F,0x72,0x27,0x73,0x40,0x72,0x65,0x66,0x72,0x65,0x73,
+	0x68,0x69,0x67,0x68,0x2C,0x20,0x79,0x6F,0x75,0x27,0x6C,0x6C,
-	0x68,0x20,0x72,0x61,0x74,0x65,0x20,0x69,0x73,0x20,0x6E,0x6F,
+	0x3A,0x67,0x65,0x74,0x20,0x64,0x69,0x73,0x74,0x6F,0x72,0x74,
-	0x74,0x20,0x36,0x30,0x48,0x7A,0x20,0x28,0x6F,0x72,0x20,0x35,
+	0x69,0x6F,0x6E,0x2E,0x20,0x33,0x32,0x58,0x20,0x65,0x71,0x75,
-	0x39,0x48,0x7A,0x29,0x2C,0x20,0x74,0x68,0x65,0x6E,0x20,0x56,
+	0x61,0x6C,0x73,0x20,0x66,0x75,0x6C,0x6C,0x20,0x61,0x6D,0x70,
-	0x53,0x79,0x6E,0x63,0x20,0x69,0x73,0x20,0x61,0x6C,0x77,0x61,
+	0x6C,0x69,0x74,0x75,0x64,0x65,0x20,0x66,0x6F,0x72,0x20,0x6F,
-	0x79,0x73,0x20,0x6F,0x66,0x66,0x20,0x66,0x6F,0x72,0x45,0x74,
+	0x6E,0x65,0x20,0x63,0x68,0x61,0x6E,0x6E,0x65,0x6C,0x2E,0x00,
-	0x68,0x69,0x73,0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x2E,
+	0x1B,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
-	0x20,0x4E,0x6F,0x74,0x20,0x68,0x61,0x76,0x69,0x6E,0x67,0x20,
+	0x46,0x72,0x65,0x71,0x75,0x65,0x6E,0x63,0x79,0x20,0x74,0x61,
-	0x56,0x53,0x79,0x6E,0x63,0x20,0x77,0x69,0x6C,0x6C,0x20,0x72,
+	0x62,0x6C,0x65,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,
-	0x65,0x73,0x75,0x6C,0x74,0x20,0x69,0x6E,0x20,0x6C,0x65,0x73,
+	0x43,0x30,0x30,0x32,0x40,0x54,0x68,0x65,0x20,0x6C,0x69,0x6E,
-	0x73,0x20,0x69,0x6E,0x70,0x75,0x74,0x2F,0x76,0x69,0x64,0x65,
+	0x65,0x61,0x72,0x20,0x66,0x72,0x65,0x71,0x75,0x65,0x6E,0x63,
-	0x6F,0x20,0x64,0x65,0x6C,0x61,0x79,0x2C,0x1E,0x62,0x75,0x74,
+	0x79,0x20,0x74,0x61,0x62,0x6C,0x65,0x20,0x6D,0x61,0x6B,0x65,
-	0x20,0x61,0x6C,0x73,0x6F,0x20,0x70,0x6F,0x74,0x65,0x6E,0x74,
+	0x73,0x20,0x61,0x6C,0x6C,0x20,0x70,0x69,0x74,0x63,0x68,0x20,
-	0x69,0x61,0x6C,0x20,0x73,0x74,0x75,0x74,0x74,0x65,0x72,0x69,
+	0x62,0x65,0x6E,0x64,0x73,0x20,0x72,0x75,0x6E,0x20,0x69,0x6E,
-	0x6E,0x67,0x2E,0x00,0x15,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,
+	0x20,0x63,0x6F,0x6E,0x73,0x74,0x61,0x6E,0x74,0x3F,0x73,0x70,
-	0x43,0x30,0x30,0x31,0x53,0x74,0x72,0x65,0x74,0x63,0x68,0x65,
+	0x65,0x65,0x64,0x2C,0x20,0x69,0x6E,0x64,0x65,0x70,0x65,0x6E,
-	0x64,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
+	0x64,0x65,0x6E,0x74,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,
-	0x30,0x32,0x4A,0x4D,0x61,0x6B,0x65,0x73,0x20,0x66,0x75,0x6C,
+	0x63,0x75,0x72,0x72,0x65,0x6E,0x74,0x20,0x66,0x72,0x65,0x71,
-	0x6C,0x73,0x63,0x72,0x65,0x65,0x6E,0x20,0x6D,0x6F,0x64,0x65,
+	0x75,0x65,0x6E,0x63,0x79,0x2E,0x20,0x49,0x66,0x20,0x79,0x6F,
-	0x20,0x63,0x6F,0x6D,0x70,0x6C,0x65,0x74,0x65,0x6C,0x79,0x20,
+	0x75,0x20,0x73,0x77,0x69,0x74,0x63,0x68,0x20,0x74,0x68,0x69,
-	0x73,0x74,0x72,0x65,0x74,0x63,0x68,0x20,0x6F,0x75,0x74,0x20,
+	0x73,0x41,0x6F,0x6E,0x65,0x2C,0x20,0x6F,0x6E,0x20,0x61,0x20,
-	0x74,0x68,0x65,0x20,0x69,0x6D,0x61,0x67,0x65,0x2E,0x20,0x54,
+	0x66,0x69,0x6E,0x69,0x73,0x68,0x65,0x64,0x20,0x73,0x6F,0x6E,
-	0x68,0x69,0x73,0x20,0x63,0x61,0x6E,0x20,0x72,0x65,0x73,0x75,
+	0x67,0x2C,0x20,0x69,0x74,0x20,0x6D,0x69,0x67,0x68,0x74,0x20,
-	0x6C,0x74,0x20,0x69,0x6E,0x4E,0x61,0x6C,0x69,0x61,0x73,0x69,
+	0x73,0x6F,0x75,0x6E,0x64,0x20,0x73,0x74,0x72,0x61,0x6E,0x67,
-	0x6E,0x67,0x20,0x28,0x75,0x6E,0x65,0x76,0x65,0x6E,0x20,0x70,
+	0x65,0x20,0x69,0x66,0x20,0x74,0x68,0x65,0x20,0x73,0x6F,0x75,
-	0x69,0x78,0x65,0x6C,0x20,0x77,0x69,0x64,0x74,0x68,0x73,0x29,
+	0x6E,0x64,0x20,0x75,0x73,0x65,0x73,0x0D,0x70,0x6F,0x72,0x74,
-	0x20,0x69,0x66,0x20,0x74,0x68,0x65,0x20,0x61,0x73,0x70,0x65,
+	0x61,0x6D,0x65,0x6E,0x74,0x6F,0x65,0x73,0x2E,0x00,0x20,0x40,
-	0x63,0x74,0x20,0x72,0x61,0x74,0x69,0x6F,0x20,0x6F,0x66,0x20,
+	0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x31,0x43,0x6F,0x6E,
-	0x74,0x68,0x65,0x20,0x73,0x63,0x72,0x65,0x65,0x6E,0x20,0x69,
+	0x66,0x69,0x67,0x75,0x72,0x61,0x74,0x69,0x6F,0x6E,0x2C,0x20,
-	0x73,0x20,0x6E,0x6F,0x74,0x20,0x31,0x36,0x3A,0x31,0x30,0x2E,
+	0x4C,0x61,0x79,0x6F,0x75,0x74,0x3A,0x01,0x3E,0x29,0x3E,0x40,
-	0x52,0x54,0x68,0x65,0x20,0x22,0x50,0x69,0x78,0x65,0x6C,0x20,
+	0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x50,0x61,0x74,
-	0x66,0x69,0x6C,0x74,0x65,0x72,0x22,0x20,0x73,0x65,0x74,0x74,
+	0x74,0x65,0x72,0x6E,0x20,0x6C,0x61,0x79,0x6F,0x75,0x74,0x2C,
-	0x69,0x6E,0x67,0x20,0x63,0x61,0x6E,0x20,0x68,0x65,0x6C,0x70,
+	0x20,0x68,0x65,0x78,0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x69,
-	0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x69,0x73,0x2C,0x20,
+	0x6E,0x67,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
-	0x62,0x75,0x74,0x20,0x69,0x74,0x20,0x6D,0x61,0x6B,0x65,0x73,
+	0x30,0x30,0x32,0x41,0x49,0x66,0x20,0x79,0x6F,0x75,0x20,0x75,
-	0x20,0x74,0x68,0x65,0x20,0x69,0x6D,0x61,0x67,0x65,0x20,0x6C,
+	0x73,0x65,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x73,0x20,
-	0x6F,0x6F,0x6B,0x20,0x62,0x6C,0x75,0x72,0x72,0x79,0x2E,0x01,
+	0x74,0x68,0x61,0x74,0x20,0x61,0x72,0x65,0x20,0x6C,0x6F,0x6E,
-	0x20,0x18,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
+	0x67,0x65,0x72,0x20,0x74,0x68,0x61,0x6E,0x20,0x39,0x39,0x20,
-	0x31,0x50,0x69,0x78,0x65,0x6C,0x20,0x66,0x69,0x6C,0x74,0x65,
+	0x6C,0x69,0x6E,0x65,0x73,0x2C,0x20,0x79,0x6F,0x75,0x20,0x73,
-	0x72,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,
+	0x68,0x6F,0x75,0x6C,0x64,0x20,0x75,0x73,0x65,0x45,0x68,0x65,
-	0x30,0x32,0x52,0x41,0x70,0x70,0x6C,0x69,0x65,0x73,0x20,0x61,
+	0x78,0x20,0x63,0x6F,0x75,0x6E,0x74,0x69,0x6E,0x67,0x20,0x73,
-	0x6E,0x20,0x61,0x6E,0x74,0x69,0x2D,0x61,0x6C,0x69,0x61,0x73,
+	0x69,0x6E,0x63,0x65,0x20,0x74,0x68,0x65,0x72,0x65,0x20,0x61,
-	0x69,0x6E,0x67,0x20,0x73,0x75,0x62,0x70,0x69,0x78,0x65,0x6C,
+	0x72,0x65,0x20,0x6F,0x6E,0x6C,0x79,0x20,0x32,0x20,0x64,0x69,
-	0x20,0x66,0x69,0x6C,0x74,0x65,0x72,0x20,0x74,0x68,0x61,0x74,
+	0x67,0x69,0x74,0x73,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,
-	0x20,0x69,0x73,0x20,0x75,0x73,0x65,0x64,0x20,0x77,0x68,0x65,
+	0x6C,0x69,0x6E,0x65,0x20,0x6E,0x75,0x6D,0x62,0x65,0x72,0x20,
-	0x6E,0x20,0x74,0x68,0x65,0x20,0x77,0x69,0x6E,0x64,0x6F,0x77,
+	0x63,0x6F,0x6C,0x75,0x6D,0x6E,0x2E,0x00,0x12,0x3E,0x40,0x58,
-	0x20,0x69,0x73,0x20,0x75,0x70,0x73,0x63,0x61,0x6C,0x65,0x64,
+	0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x53,0x63,0x6F,0x70,
-	0x2E,0x3B,0x50,0x6C,0x65,0x61,0x73,0x65,0x20,0x6B,0x65,0x65,
+	0x65,0x73,0x3A,0x0B,0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,
-	0x70,0x20,0x69,0x6E,0x20,0x6D,0x69,0x6E,0x64,0x20,0x74,0x68,
+	0x30,0x30,0x32,0x43,0x22,0x53,0x74,0x64,0x2E,0x22,0x20,0x28,
-	0x61,0x74,0x20,0x74,0x68,0x69,0x73,0x20,0x77,0x69,0x6C,0x6C,
+	0x73,0x74,0x61,0x6E,0x64,0x61,0x72,0x64,0x29,0x20,0x77,0x69,
-	0x20,0x6D,0x61,0x6B,0x65,0x20,0x70,0x69,0x78,0x65,0x6C,0x73,
+	0x6C,0x6C,0x20,0x73,0x68,0x6F,0x77,0x20,0x74,0x68,0x65,0x20,
-	0x20,0x6C,0x6F,0x6F,0x6B,0x20,0x62,0x6C,0x75,0x72,0x72,0x79,
+	0x73,0x61,0x6D,0x70,0x6C,0x65,0x20,0x70,0x6F,0x69,0x6E,0x74,
-	0x2E,0x00,0x23,0x40,0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,
+	0x73,0x20,0x61,0x73,0x20,0x70,0x69,0x78,0x65,0x6C,0x73,0x20,
-	0x31,0x41,0x64,0x76,0x61,0x6E,0x63,0x65,0x64,0x20,0x65,0x64,
+	0x28,0x6C,0x69,0x6B,0x65,0x20,0x46,0x54,0x32,0x29,0x2E,0x41,
-	0x69,0x74,0x20,0x66,0x75,0x6E,0x63,0x74,0x69,0x6F,0x6E,0x73,
+	0x22,0x4C,0x69,0x6E,0x65,0x64,0x22,0x20,0x77,0x69,0x6C,0x6C,
-	0x3A,0x20,0x01,0x3E,0x1E,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,
+	0x20,0x64,0x72,0x61,0x77,0x20,0x6C,0x69,0x6E,0x65,0x73,0x20,
-	0x43,0x30,0x30,0x31,0x43,0x6F,0x70,0x79,0x2F,0x50,0x61,0x73,
+	0x62,0x65,0x74,0x77,0x65,0x65,0x6E,0x20,0x74,0x68,0x65,0x20,
-	0x74,0x65,0x20,0x6D,0x61,0x73,0x6B,0x69,0x6E,0x67,0x3A,0x0B,
+	0x70,0x6F,0x69,0x6E,0x74,0x73,0x2C,0x20,0x6C,0x69,0x6B,0x65,
-	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x37,
+	0x20,0x61,0x6E,0x20,0x6F,0x73,0x63,0x69,0x6C,0x6C,0x6F,0x73,
-	0x54,0x68,0x65,0x20,0x6D,0x61,0x73,0x6B,0x69,0x6E,0x67,0x20,
+	0x63,0x6F,0x70,0x65,0x2E,0x00,0x27,0x40,0x58,0x30,0x32,0x30,
-	0x69,0x73,0x20,0x75,0x73,0x65,0x64,0x20,0x66,0x6F,0x72,0x20,
+	0x40,0x43,0x30,0x30,0x31,0x43,0x6F,0x6E,0x66,0x69,0x67,0x75,
-	0x63,0x6F,0x70,0x79,0x69,0x6E,0x67,0x2F,0x70,0x61,0x73,0x74,
+	0x72,0x61,0x74,0x69,0x6F,0x6E,0x2C,0x20,0x4D,0x69,0x73,0x63,
-	0x69,0x6E,0x67,0x20,0x6F,0x6E,0x6C,0x79,0x20,0x70,0x61,0x72,
+	0x65,0x6C,0x6C,0x61,0x6E,0x65,0x6F,0x75,0x73,0x3A,0x01,0x3E,
-	0x74,0x73,0x20,0x6F,0x66,0x20,0x61,0x46,0x22,0x6E,0x6F,0x74,
+	0x15,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,
-	0x65,0x2D,0x63,0x65,0x6C,0x6C,0x22,0x2E,0x20,0x54,0x68,0x65,
+	0x56,0x53,0x79,0x6E,0x63,0x20,0x6F,0x66,0x66,0x3A,0x0B,0x3E,
-	0x20,0x64,0x69,0x66,0x66,0x65,0x72,0x65,0x6E,0x74,0x20,0x70,
+	0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x3F,0x54,
-	0x61,0x72,0x74,0x73,0x20,0x6F,0x66,0x20,0x61,0x20,0x22,0x6E,
+	0x65,0x6C,0x6C,0x73,0x20,0x74,0x68,0x65,0x20,0x70,0x72,0x6F,
-	0x6F,0x74,0x65,0x2D,0x63,0x65,0x6C,0x6C,0x22,0x20,0x69,0x73,
+	0x67,0x72,0x61,0x6D,0x20,0x74,0x6F,0x20,0x6E,0x6F,0x74,0x20,
-	0x20,0x4E,0x6F,0x74,0x65,0x2C,0x20,0x49,0x6E,0x73,0x74,0x72,
+	0x75,0x73,0x65,0x20,0x56,0x53,0x79,0x6E,0x63,0x20,0x66,0x6F,
-	0x2E,0x20,0x6E,0x72,0x2E,0x2C,0x20,0x56,0x6F,0x6C,0x75,0x6D,
+	0x72,0x20,0x76,0x69,0x64,0x65,0x6F,0x2E,0x20,0x49,0x66,0x20,
-	0x65,0x2C,0x20,0x45,0x66,0x66,0x65,0x63,0x74,0x20,0x6E,0x72,
+	0x79,0x6F,0x75,0x72,0x20,0x6D,0x6F,0x6E,0x69,0x74,0x6F,0x72,
-	0x20,0x26,0x20,0x45,0x66,0x66,0x65,0x63,0x74,0x20,0x64,0x61,
+	0x27,0x73,0x40,0x72,0x65,0x66,0x72,0x65,0x73,0x68,0x20,0x72,
-	0x74,0x61,0x2E,0x34,0x3E,0x41,0x73,0x20,0x79,0x6F,0x75,0x20,
+	0x61,0x74,0x65,0x20,0x69,0x73,0x20,0x6E,0x6F,0x74,0x20,0x36,
-	0x63,0x61,0x6E,0x20,0x73,0x65,0x65,0x20,0x69,0x6E,0x20,0x74,
+	0x30,0x48,0x7A,0x20,0x28,0x6F,0x72,0x20,0x35,0x39,0x48,0x7A,
-	0x68,0x65,0x20,0x77,0x69,0x6E,0x64,0x6F,0x77,0x20,0x74,0x68,
+	0x29,0x2C,0x20,0x74,0x68,0x65,0x6E,0x20,0x56,0x53,0x79,0x6E,
-	0x65,0x72,0x65,0x20,0x61,0x72,0x65,0x20,0x33,0x20,0x63,0x6F,
+	0x63,0x20,0x69,0x73,0x20,0x61,0x6C,0x77,0x61,0x79,0x73,0x20,
-	0x6C,0x75,0x6D,0x6E,0x73,0x20,0x6F,0x66,0x3D,0x22,0x65,0x6E,
+	0x6F,0x66,0x66,0x20,0x66,0x6F,0x72,0x45,0x74,0x68,0x69,0x73,
-	0x61,0x62,0x6C,0x65,0x2F,0x64,0x69,0x73,0x61,0x62,0x6C,0x65,
+	0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x2E,0x20,0x4E,0x6F,
-	0x20,0x62,0x75,0x74,0x74,0x6F,0x6E,0x73,0x22,0x20,0x77,0x68,
+	0x74,0x20,0x68,0x61,0x76,0x69,0x6E,0x67,0x20,0x56,0x53,0x79,
-	0x69,0x63,0x68,0x20,0x68,0x61,0x73,0x20,0x74,0x68,0x65,0x20,
+	0x6E,0x63,0x20,0x77,0x69,0x6C,0x6C,0x20,0x72,0x65,0x73,0x75,
-	0x6C,0x65,0x74,0x74,0x65,0x72,0x73,0x20,0x43,0x2C,0x50,0x20,
+	0x6C,0x74,0x20,0x69,0x6E,0x20,0x6C,0x65,0x73,0x73,0x20,0x69,
-	0x26,0x20,0x54,0x20,0x61,0x62,0x6F,0x76,0x65,0x2E,0x45,0x3E,
+	0x6E,0x70,0x75,0x74,0x2F,0x76,0x69,0x64,0x65,0x6F,0x20,0x64,
-	0x43,0x20,0x6D,0x65,0x61,0x6E,0x73,0x20,0x63,0x6F,0x70,0x79,
+	0x65,0x6C,0x61,0x79,0x2C,0x1E,0x62,0x75,0x74,0x20,0x61,0x6C,
-	0x2C,0x20,0x69,0x74,0x20,0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,
+	0x73,0x6F,0x20,0x70,0x6F,0x74,0x65,0x6E,0x74,0x69,0x61,0x6C,
-	0x73,0x20,0x77,0x68,0x69,0x63,0x68,0x20,0x70,0x61,0x72,0x74,
+	0x20,0x73,0x74,0x75,0x74,0x74,0x65,0x72,0x69,0x6E,0x67,0x2E,
-	0x73,0x20,0x74,0x68,0x61,0x74,0x20,0x67,0x6F,0x65,0x73,0x20,
+	0x00,0x15,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
-	0x69,0x6E,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x63,0x6F,0x70,
+	0x31,0x53,0x74,0x72,0x65,0x74,0x63,0x68,0x65,0x64,0x3A,0x0B,
-	0x79,0x62,0x75,0x66,0x66,0x65,0x72,0x2E,0x3E,0x3E,0x50,0x20,
+	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x4A,
-	0x6D,0x65,0x61,0x6E,0x73,0x20,0x70,0x61,0x73,0x74,0x65,0x20,
+	0x4D,0x61,0x6B,0x65,0x73,0x20,0x66,0x75,0x6C,0x6C,0x73,0x63,
-	0x61,0x6E,0x64,0x20,0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x73,
+	0x72,0x65,0x65,0x6E,0x20,0x6D,0x6F,0x64,0x65,0x20,0x63,0x6F,
-	0x20,0x77,0x68,0x69,0x63,0x68,0x20,0x70,0x61,0x72,0x74,0x73,
+	0x6D,0x70,0x6C,0x65,0x74,0x65,0x6C,0x79,0x20,0x73,0x74,0x72,
-	0x20,0x74,0x68,0x61,0x74,0x20,0x67,0x6F,0x65,0x73,0x20,0x6F,
+	0x65,0x74,0x63,0x68,0x20,0x6F,0x75,0x74,0x20,0x74,0x68,0x65,
-	0x75,0x74,0x20,0x66,0x72,0x6F,0x6D,0x20,0x74,0x68,0x65,0x0B,
+	0x20,0x69,0x6D,0x61,0x67,0x65,0x2E,0x20,0x54,0x68,0x69,0x73,
-	0x63,0x6F,0x70,0x79,0x62,0x75,0x66,0x66,0x65,0x72,0x2E,0x45,
+	0x20,0x63,0x61,0x6E,0x20,0x72,0x65,0x73,0x75,0x6C,0x74,0x20,
-	0x3E,0x54,0x20,0x6D,0x65,0x61,0x6E,0x73,0x20,0x74,0x72,0x61,
+	0x69,0x6E,0x4E,0x61,0x6C,0x69,0x61,0x73,0x69,0x6E,0x67,0x20,
-	0x6E,0x73,0x70,0x61,0x72,0x65,0x6E,0x63,0x79,0x2E,0x20,0x49,
+	0x28,0x75,0x6E,0x65,0x76,0x65,0x6E,0x20,0x70,0x69,0x78,0x65,
-	0x66,0x20,0x69,0x74,0x27,0x73,0x20,0x65,0x6E,0x61,0x62,0x6C,
+	0x6C,0x20,0x77,0x69,0x64,0x74,0x68,0x73,0x29,0x20,0x69,0x66,
-	0x65,0x64,0x2C,0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x73,0x74,
+	0x20,0x74,0x68,0x65,0x20,0x61,0x73,0x70,0x65,0x63,0x74,0x20,
-	0x69,0x6E,0x67,0x20,0x64,0x6F,0x65,0x73,0x6E,0x27,0x74,0x20,
+	0x72,0x61,0x74,0x69,0x6F,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,
-	0x6F,0x76,0x65,0x72,0x77,0x72,0x69,0x74,0x65,0x3D,0x64,0x61,
+	0x20,0x73,0x63,0x72,0x65,0x65,0x6E,0x20,0x69,0x73,0x20,0x6E,
-	0x74,0x61,0x20,0x77,0x69,0x74,0x68,0x20,0x6E,0x69,0x6C,0x2D,
+	0x6F,0x74,0x20,0x31,0x36,0x3A,0x31,0x30,0x2E,0x52,0x54,0x68,
-	0x69,0x6E,0x66,0x6F,0x72,0x6D,0x61,0x74,0x69,0x6F,0x6E,0x2C,
+	0x65,0x20,0x22,0x50,0x69,0x78,0x65,0x6C,0x20,0x66,0x69,0x6C,
-	0x20,0x6F,0x6E,0x6C,0x79,0x20,0x77,0x69,0x74,0x68,0x20,0x61,
+	0x74,0x65,0x72,0x22,0x20,0x73,0x65,0x74,0x74,0x69,0x6E,0x67,
-	0x20,0x6E,0x6F,0x74,0x65,0x20,0x6F,0x72,0x20,0x61,0x20,0x6E,
+	0x20,0x63,0x61,0x6E,0x20,0x68,0x65,0x6C,0x70,0x20,0x77,0x69,
-	0x75,0x6D,0x62,0x65,0x72,0x20,0x3C,0x3E,0x20,0x30,0x2E,0x01,
+	0x74,0x68,0x20,0x74,0x68,0x69,0x73,0x2C,0x20,0x62,0x75,0x74,
-	0x3E,0x40,0x3E,0x54,0x68,0x65,0x20,0x63,0x75,0x74,0x20,0x66,
+	0x20,0x69,0x74,0x20,0x6D,0x61,0x6B,0x65,0x73,0x20,0x74,0x68,
-	0x75,0x6E,0x63,0x74,0x69,0x6F,0x6E,0x73,0x20,0x77,0x6F,0x72,
+	0x65,0x20,0x69,0x6D,0x61,0x67,0x65,0x20,0x6C,0x6F,0x6F,0x6B,
-	0x6B,0x73,0x20,0x6C,0x69,0x6B,0x65,0x20,0x70,0x61,0x73,0x74,
+	0x20,0x62,0x6C,0x75,0x72,0x72,0x79,0x2E,0x01,0x20,0x18,0x3E,
-	0x69,0x6E,0x67,0x20,0x77,0x69,0x74,0x68,0x20,0x7A,0x65,0x72,
+	0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,0x31,0x50,0x69,
-	0x6F,0x2D,0x64,0x61,0x74,0x61,0x2E,0x20,0x54,0x68,0x69,0x73,
+	0x78,0x65,0x6C,0x20,0x66,0x69,0x6C,0x74,0x65,0x72,0x3A,0x0B,
-	0x20,0x6D,0x65,0x61,0x6E,0x73,0x3B,0x74,0x68,0x61,0x74,0x20,
+	0x3E,0x40,0x58,0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x52,
-	0x74,0x68,0x65,0x20,0x63,0x75,0x74,0x74,0x69,0x6E,0x67,0x20,
+	0x41,0x70,0x70,0x6C,0x69,0x65,0x73,0x20,0x61,0x6E,0x20,0x61,
-	0x69,0x73,0x20,0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x6C,0x65,
+	0x6E,0x74,0x69,0x2D,0x61,0x6C,0x69,0x61,0x73,0x69,0x6E,0x67,
-	0x64,0x20,0x77,0x69,0x74,0x68,0x20,0x50,0x2D,0x63,0x6F,0x6C,
+	0x20,0x73,0x75,0x62,0x70,0x69,0x78,0x65,0x6C,0x20,0x66,0x69,
-	0x75,0x6D,0x6E,0x20,0x28,0x6F,0x72,0x20,0x54,0x2D,0x63,0x6F,
+	0x6C,0x74,0x65,0x72,0x20,0x74,0x68,0x61,0x74,0x20,0x69,0x73,
-	0x6C,0x75,0x6D,0x6E,0x29,0x2E,0x3C,0x3E,0x57,0x68,0x65,0x6E,
+	0x20,0x75,0x73,0x65,0x64,0x20,0x77,0x68,0x65,0x6E,0x20,0x74,
-	0x20,0x79,0x6F,0x75,0x20,0x63,0x6F,0x70,0x79,0x20,0x64,0x61,
+	0x68,0x65,0x20,0x77,0x69,0x6E,0x64,0x6F,0x77,0x20,0x69,0x73,
-	0x74,0x61,0x20,0x77,0x69,0x74,0x68,0x20,0x6D,0x61,0x73,0x6B,
+	0x20,0x75,0x70,0x73,0x63,0x61,0x6C,0x65,0x64,0x2E,0x3B,0x50,
-	0x69,0x6E,0x67,0x2C,0x20,0x74,0x68,0x65,0x20,0x64,0x69,0x73,
+	0x6C,0x65,0x61,0x73,0x65,0x20,0x6B,0x65,0x65,0x70,0x20,0x69,
-	0x61,0x62,0x6C,0x65,0x64,0x20,0x70,0x61,0x72,0x74,0x73,0x20,
+	0x6E,0x20,0x6D,0x69,0x6E,0x64,0x20,0x74,0x68,0x61,0x74,0x20,
-	0x61,0x72,0x65,0x20,0x6E,0x6F,0x74,0x43,0x63,0x6C,0x65,0x61,
+	0x74,0x68,0x69,0x73,0x20,0x77,0x69,0x6C,0x6C,0x20,0x6D,0x61,
-	0x72,0x65,0x64,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x63,
+	0x6B,0x65,0x20,0x70,0x69,0x78,0x65,0x6C,0x73,0x20,0x6C,0x6F,
-	0x6F,0x70,0x79,0x62,0x75,0x66,0x66,0x65,0x72,0x2E,0x20,0x28,
+	0x6F,0x6B,0x20,0x62,0x6C,0x75,0x72,0x72,0x79,0x2E,0x00,0x23,
-	0x4D,0x61,0x6B,0x69,0x6E,0x67,0x20,0x69,0x74,0x20,0x70,0x6F,
+	0x40,0x58,0x30,0x32,0x30,0x40,0x43,0x30,0x30,0x31,0x41,0x64,
-	0x73,0x73,0x69,0x62,0x6C,0x65,0x20,0x74,0x6F,0x20,0x63,0x6F,
+	0x76,0x61,0x6E,0x63,0x65,0x64,0x20,0x65,0x64,0x69,0x74,0x20,
-	0x6C,0x6C,0x65,0x63,0x74,0x20,0x64,0x61,0x74,0x61,0x20,0x66,
+	0x66,0x75,0x6E,0x63,0x74,0x69,0x6F,0x6E,0x73,0x3A,0x20,0x01,
-	0x72,0x6F,0x6D,0x27,0x73,0x65,0x76,0x65,0x72,0x61,0x6C,0x20,
+	0x3E,0x1E,0x3E,0x40,0x58,0x30,0x34,0x30,0x40,0x43,0x30,0x30,
-	0x6C,0x6F,0x63,0x61,0x74,0x69,0x6F,0x6E,0x73,0x20,0x69,0x6E,
+	0x31,0x43,0x6F,0x70,0x79,0x2F,0x50,0x61,0x73,0x74,0x65,0x20,
-	0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x63,0x6F,0x70,0x79,0x62,
+	0x6D,0x61,0x73,0x6B,0x69,0x6E,0x67,0x3A,0x0B,0x3E,0x40,0x58,
-	0x75,0x66,0x66,0x65,0x72,0x2E,0x29,0x00,0x03,0x45,0x4E,0x44,
+	0x30,0x36,0x30,0x40,0x43,0x30,0x30,0x32,0x37,0x54,0x68,0x65,
-	0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
+	0x20,0x6D,0x61,0x73,0x6B,0x69,0x6E,0x67,0x20,0x69,0x73,0x20,
+	0x75,0x73,0x65,0x64,0x20,0x66,0x6F,0x72,0x20,0x63,0x6F,0x70,
+	0x79,0x69,0x6E,0x67,0x2F,0x70,0x61,0x73,0x74,0x69,0x6E,0x67,
+	0x20,0x6F,0x6E,0x6C,0x79,0x20,0x70,0x61,0x72,0x74,0x73,0x20,
+	0x6F,0x66,0x20,0x61,0x46,0x22,0x6E,0x6F,0x74,0x65,0x2D,0x63,
+	0x65,0x6C,0x6C,0x22,0x2E,0x20,0x54,0x68,0x65,0x20,0x64,0x69,
+	0x66,0x66,0x65,0x72,0x65,0x6E,0x74,0x20,0x70,0x61,0x72,0x74,
+	0x73,0x20,0x6F,0x66,0x20,0x61,0x20,0x22,0x6E,0x6F,0x74,0x65,
+	0x2D,0x63,0x65,0x6C,0x6C,0x22,0x20,0x69,0x73,0x20,0x4E,0x6F,
+	0x74,0x65,0x2C,0x20,0x49,0x6E,0x73,0x74,0x72,0x2E,0x20,0x6E,
+	0x72,0x2E,0x2C,0x20,0x56,0x6F,0x6C,0x75,0x6D,0x65,0x2C,0x20,
+	0x45,0x66,0x66,0x65,0x63,0x74,0x20,0x6E,0x72,0x20,0x26,0x20,
+	0x45,0x66,0x66,0x65,0x63,0x74,0x20,0x64,0x61,0x74,0x61,0x2E,
+	0x34,0x3E,0x41,0x73,0x20,0x79,0x6F,0x75,0x20,0x63,0x61,0x6E,
+	0x20,0x73,0x65,0x65,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,
+	0x77,0x69,0x6E,0x64,0x6F,0x77,0x20,0x74,0x68,0x65,0x72,0x65,
+	0x20,0x61,0x72,0x65,0x20,0x33,0x20,0x63,0x6F,0x6C,0x75,0x6D,
+	0x6E,0x73,0x20,0x6F,0x66,0x3D,0x22,0x65,0x6E,0x61,0x62,0x6C,
+	0x65,0x2F,0x64,0x69,0x73,0x61,0x62,0x6C,0x65,0x20,0x62,0x75,
+	0x74,0x74,0x6F,0x6E,0x73,0x22,0x20,0x77,0x68,0x69,0x63,0x68,
+	0x20,0x68,0x61,0x73,0x20,0x74,0x68,0x65,0x20,0x6C,0x65,0x74,
+	0x74,0x65,0x72,0x73,0x20,0x43,0x2C,0x50,0x20,0x26,0x20,0x54,
+	0x20,0x61,0x62,0x6F,0x76,0x65,0x2E,0x45,0x3E,0x43,0x20,0x6D,
+	0x65,0x61,0x6E,0x73,0x20,0x63,0x6F,0x70,0x79,0x2C,0x20,0x69,
+	0x74,0x20,0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x73,0x20,0x77,
+	0x68,0x69,0x63,0x68,0x20,0x70,0x61,0x72,0x74,0x73,0x20,0x74,
+	0x68,0x61,0x74,0x20,0x67,0x6F,0x65,0x73,0x20,0x69,0x6E,0x74,
+	0x6F,0x20,0x74,0x68,0x65,0x20,0x63,0x6F,0x70,0x79,0x62,0x75,
+	0x66,0x66,0x65,0x72,0x2E,0x3E,0x3E,0x50,0x20,0x6D,0x65,0x61,
+	0x6E,0x73,0x20,0x70,0x61,0x73,0x74,0x65,0x20,0x61,0x6E,0x64,
+	0x20,0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x73,0x20,0x77,0x68,
+	0x69,0x63,0x68,0x20,0x70,0x61,0x72,0x74,0x73,0x20,0x74,0x68,
+	0x61,0x74,0x20,0x67,0x6F,0x65,0x73,0x20,0x6F,0x75,0x74,0x20,
+	0x66,0x72,0x6F,0x6D,0x20,0x74,0x68,0x65,0x0B,0x63,0x6F,0x70,
+	0x79,0x62,0x75,0x66,0x66,0x65,0x72,0x2E,0x45,0x3E,0x54,0x20,
+	0x6D,0x65,0x61,0x6E,0x73,0x20,0x74,0x72,0x61,0x6E,0x73,0x70,
+	0x61,0x72,0x65,0x6E,0x63,0x79,0x2E,0x20,0x49,0x66,0x20,0x69,
+	0x74,0x27,0x73,0x20,0x65,0x6E,0x61,0x62,0x6C,0x65,0x64,0x2C,
+	0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x73,0x74,0x69,0x6E,0x67,
+	0x20,0x64,0x6F,0x65,0x73,0x6E,0x27,0x74,0x20,0x6F,0x76,0x65,
+	0x72,0x77,0x72,0x69,0x74,0x65,0x3D,0x64,0x61,0x74,0x61,0x20,
+	0x77,0x69,0x74,0x68,0x20,0x6E,0x69,0x6C,0x2D,0x69,0x6E,0x66,
+	0x6F,0x72,0x6D,0x61,0x74,0x69,0x6F,0x6E,0x2C,0x20,0x6F,0x6E,
+	0x6C,0x79,0x20,0x77,0x69,0x74,0x68,0x20,0x61,0x20,0x6E,0x6F,
+	0x74,0x65,0x20,0x6F,0x72,0x20,0x61,0x20,0x6E,0x75,0x6D,0x62,
+	0x65,0x72,0x20,0x3C,0x3E,0x20,0x30,0x2E,0x01,0x3E,0x40,0x3E,
+	0x54,0x68,0x65,0x20,0x63,0x75,0x74,0x20,0x66,0x75,0x6E,0x63,
+	0x74,0x69,0x6F,0x6E,0x73,0x20,0x77,0x6F,0x72,0x6B,0x73,0x20,
+	0x6C,0x69,0x6B,0x65,0x20,0x70,0x61,0x73,0x74,0x69,0x6E,0x67,
+	0x20,0x77,0x69,0x74,0x68,0x20,0x7A,0x65,0x72,0x6F,0x2D,0x64,
+	0x61,0x74,0x61,0x2E,0x20,0x54,0x68,0x69,0x73,0x20,0x6D,0x65,
+	0x61,0x6E,0x73,0x3B,0x74,0x68,0x61,0x74,0x20,0x74,0x68,0x65,
+	0x20,0x63,0x75,0x74,0x74,0x69,0x6E,0x67,0x20,0x69,0x73,0x20,
+	0x63,0x6F,0x6E,0x74,0x72,0x6F,0x6C,0x6C,0x65,0x64,0x20,0x77,
+	0x69,0x74,0x68,0x20,0x50,0x2D,0x63,0x6F,0x6C,0x75,0x6D,0x6E,
+	0x20,0x28,0x6F,0x72,0x20,0x54,0x2D,0x63,0x6F,0x6C,0x75,0x6D,
+	0x6E,0x29,0x2E,0x3C,0x3E,0x57,0x68,0x65,0x6E,0x20,0x79,0x6F,
+	0x75,0x20,0x63,0x6F,0x70,0x79,0x20,0x64,0x61,0x74,0x61,0x20,
+	0x77,0x69,0x74,0x68,0x20,0x6D,0x61,0x73,0x6B,0x69,0x6E,0x67,
+	0x2C,0x20,0x74,0x68,0x65,0x20,0x64,0x69,0x73,0x61,0x62,0x6C,
+	0x65,0x64,0x20,0x70,0x61,0x72,0x74,0x73,0x20,0x61,0x72,0x65,
+	0x20,0x6E,0x6F,0x74,0x43,0x63,0x6C,0x65,0x61,0x72,0x65,0x64,
+	0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x63,0x6F,0x70,0x79,
+	0x62,0x75,0x66,0x66,0x65,0x72,0x2E,0x20,0x28,0x4D,0x61,0x6B,
+	0x69,0x6E,0x67,0x20,0x69,0x74,0x20,0x70,0x6F,0x73,0x73,0x69,
+	0x62,0x6C,0x65,0x20,0x74,0x6F,0x20,0x63,0x6F,0x6C,0x6C,0x65,
+	0x63,0x74,0x20,0x64,0x61,0x74,0x61,0x20,0x66,0x72,0x6F,0x6D,
+	0x27,0x73,0x65,0x76,0x65,0x72,0x61,0x6C,0x20,0x6C,0x6F,0x63,
+	0x61,0x74,0x69,0x6F,0x6E,0x73,0x20,0x69,0x6E,0x74,0x6F,0x20,
+	0x74,0x68,0x65,0x20,0x63,0x6F,0x70,0x79,0x62,0x75,0x66,0x66,
+	0x65,0x72,0x2E,0x29,0x00,0x03,0x45,0x4E,0x44,0x4C,0x3B,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
-	0x2A,0x2A,0x2A,0x2A,0x2A,0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
+	0x2A,0x2A,0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
-	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x0E,0x40,
-	0x4C,0x50,0x72,0x6F,0x62,0x6C,0x65,0x6D,0x73,0x2F,0x46,0x41,
-	0x51,0x06,0x3E,0x40,0x58,0x30,0x32,0x30,0x2A,0x3E,0x40,0x43,
-	0x30,0x30,0x31,0x51,0x3A,0x20,0x48,0x6F,0x77,0x20,0x63,0x61,
-	0x6E,0x20,0x49,0x20,0x74,0x6F,0x67,0x67,0x6C,0x65,0x20,0x66,
-	0x75,0x6C,0x6C,0x73,0x63,0x72,0x65,0x65,0x6E,0x20,0x6D,0x6F,
-	0x64,0x65,0x3F,0x37,0x3E,0x40,0x43,0x30,0x30,0x32,0x41,0x3A,
-	0x20,0x50,0x72,0x65,0x73,0x73,0x20,0x41,0x6C,0x74,0x2B,0x45,
-	0x6E,0x74,0x65,0x72,0x20,0x28,0x43,0x74,0x72,0x6C,0x2B,0x43,
-	0x6D,0x64,0x2B,0x46,0x20,0x61,0x6C,0x73,0x6F,0x20,0x77,0x6F,
-	0x72,0x6B,0x73,0x20,0x6F,0x6E,0x20,0x4D,0x61,0x63,0x29,0x06,
-	0x3E,0x40,0x58,0x30,0x32,0x30,0x45,0x3E,0x40,0x43,0x30,0x30,
-	0x31,0x51,0x3A,0x20,0x48,0x6F,0x77,0x20,0x63,0x61,0x6E,0x20,
-	0x49,0x20,0x6D,0x61,0x6B,0x65,0x20,0x66,0x75,0x6C,0x6C,0x73,
-	0x63,0x72,0x65,0x65,0x6E,0x20,0x6D,0x6F,0x64,0x65,0x20,0x73,
-	0x74,0x72,0x65,0x74,0x63,0x68,0x20,0x6F,0x75,0x74,0x20,0x74,
-	0x68,0x65,0x20,0x77,0x68,0x6F,0x6C,0x65,0x20,0x73,0x63,0x72,
-	0x65,0x65,0x6E,0x3F,0x37,0x3E,0x40,0x43,0x30,0x30,0x32,0x41,
-	0x3A,0x20,0x45,0x6E,0x61,0x62,0x6C,0x65,0x20,0x22,0x53,0x74,
-	0x72,0x65,0x74,0x63,0x68,0x65,0x64,0x22,0x20,0x69,0x6E,0x20,
-	0x43,0x6F,0x6E,0x66,0x69,0x67,0x20,0x2D,0x3E,0x20,0x4D,0x69,
-	0x73,0x63,0x65,0x6C,0x6C,0x61,0x6E,0x65,0x6F,0x75,0x73,0x2E,
-	0x4E,0x3E,0x40,0x58,0x30,0x33,0x35,0x54,0x68,0x69,0x73,0x20,
-	0x77,0x69,0x6C,0x6C,0x20,0x72,0x65,0x73,0x75,0x6C,0x74,0x20,
-	0x69,0x6E,0x20,0x75,0x6E,0x65,0x76,0x65,0x6E,0x20,0x70,0x69,
-	0x78,0x65,0x6C,0x20,0x77,0x69,0x64,0x74,0x68,0x73,0x2E,0x20,
-	0x49,0x66,0x20,0x79,0x6F,0x75,0x20,0x77,0x61,0x6E,0x74,0x20,
-	0x74,0x6F,0x20,0x66,0x69,0x78,0x20,0x74,0x68,0x69,0x73,0x2C,
-	0x20,0x65,0x6E,0x61,0x62,0x6C,0x65,0x3D,0x22,0x50,0x69,0x78,
-	0x65,0x6C,0x20,0x66,0x69,0x6C,0x74,0x65,0x72,0x22,0x20,0x28,
-	0x74,0x68,0x6F,0x75,0x67,0x68,0x20,0x74,0x68,0x69,0x73,0x20,
-	0x77,0x69,0x6C,0x6C,0x20,0x6D,0x61,0x6B,0x65,0x20,0x74,0x68,
-	0x65,0x20,0x69,0x6D,0x61,0x67,0x65,0x20,0x6C,0x6F,0x6F,0x6B,
-	0x20,0x62,0x6C,0x75,0x72,0x72,0x79,0x29,0x2E,0x06,0x3E,0x40,
-	0x58,0x30,0x32,0x30,0x27,0x3E,0x40,0x43,0x30,0x30,0x31,0x51,
-	0x3A,0x20,0x49,0x20,0x63,0x61,0x6E,0x27,0x74,0x20,0x75,0x73,
-	0x65,0x20,0x41,0x6C,0x74,0x2B,0x46,0x34,0x20,0x61,0x6E,0x64,
-	0x20,0x41,0x6C,0x74,0x2B,0x46,0x35,0x21,0x4E,0x3E,0x40,0x43,
-	0x30,0x30,0x32,0x41,0x3A,0x20,0x57,0x69,0x6E,0x64,0x6F,0x77,
-	0x73,0x3A,0x20,0x49,0x66,0x20,0x79,0x6F,0x75,0x20,0x68,0x61,
-	0x76,0x65,0x20,0x47,0x65,0x46,0x6F,0x72,0x63,0x65,0x20,0x45,
-	0x78,0x70,0x65,0x72,0x69,0x65,0x6E,0x63,0x65,0x20,0x69,0x6E,
-	0x73,0x74,0x61,0x6C,0x6C,0x65,0x64,0x2C,0x20,0x79,0x6F,0x75,
-	0x20,0x6E,0x65,0x65,0x64,0x20,0x74,0x6F,0x20,0x63,0x68,0x61,
-	0x6E,0x67,0x65,0x2B,0x3E,0x40,0x58,0x30,0x33,0x35,0x74,0x68,
-	0x65,0x20,0x6B,0x65,0x79,0x62,0x69,0x6E,0x64,0x69,0x6E,0x67,
-	0x73,0x20,0x69,0x6E,0x20,0x69,0x74,0x73,0x20,0x73,0x65,0x74,
-	0x74,0x69,0x6E,0x67,0x73,0x20,0x70,0x61,0x67,0x65,0x2E,0x57,
-	0x3E,0x6D,0x61,0x63,0x4F,0x53,0x2F,0x4F,0x53,0x20,0x58,0x3A,
-	0x20,0x43,0x68,0x61,0x6E,0x67,0x65,0x20,0x41,0x6C,0x74,0x2B,
-	0x46,0x34,0x2F,0x41,0x6C,0x74,0x2B,0x46,0x35,0x20,0x6B,0x65,
-	0x79,0x73,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x4F,0x53,
-	0x20,0x74,0x6F,0x20,0x73,0x6F,0x6D,0x65,0x74,0x68,0x69,0x6E,
-	0x67,0x20,0x65,0x6C,0x73,0x65,0x2E,0x20,0x41,0x6C,0x73,0x6F,
-	0x20,0x66,0x6F,0x72,0x20,0x47,0x4E,0x55,0x2F,0x4C,0x69,0x6E,
-	0x75,0x78,0x2E,0x06,0x3E,0x40,0x58,0x30,0x32,0x30,0x2B,0x3E,
-	0x40,0x43,0x30,0x30,0x31,0x51,0x3A,0x20,0x54,0x68,0x65,0x20,
-	0x6D,0x6F,0x75,0x73,0x65,0x20,0x63,0x75,0x72,0x73,0x6F,0x72,
-	0x20,0x69,0x73,0x20,0x64,0x65,0x6C,0x61,0x79,0x65,0x64,0x2F,
-	0x6C,0x61,0x67,0x67,0x79,0x21,0x44,0x3E,0x40,0x43,0x30,0x30,
-	0x32,0x41,0x3A,0x20,0x4D,0x61,0x6B,0x65,0x20,0x73,0x75,0x72,
-	0x65,0x20,0x22,0x53,0x6F,0x66,0x74,0x77,0x61,0x72,0x65,0x20,
-	0x6D,0x6F,0x75,0x73,0x65,0x22,0x20,0x69,0x73,0x20,0x64,0x69,
-	0x73,0x61,0x62,0x6C,0x65,0x64,0x20,0x69,0x6E,0x20,0x43,0x6F,
-	0x6E,0x66,0x69,0x67,0x20,0x2D,0x3E,0x20,0x4C,0x61,0x79,0x6F,
-	0x75,0x74,0x2E,0x4B,0x3E,0x40,0x58,0x30,0x33,0x35,0x41,0x6C,
-	0x74,0x65,0x72,0x6E,0x61,0x74,0x69,0x76,0x65,0x6C,0x79,0x2C,
-	0x20,0x79,0x6F,0x75,0x20,0x63,0x61,0x6E,0x20,0x65,0x6E,0x61,
-	0x62,0x6C,0x65,0x20,0x22,0x56,0x53,0x79,0x6E,0x63,0x20,0x6F,
-	0x66,0x66,0x22,0x20,0x69,0x6E,0x20,0x43,0x6F,0x6E,0x66,0x69,
-	0x67,0x20,0x2D,0x3E,0x20,0x4D,0x69,0x73,0x63,0x65,0x6C,0x6C,
-	0x61,0x6E,0x65,0x6F,0x75,0x73,0x2E,0x46,0x3E,0x54,0x68,0x69,
-	0x73,0x20,0x68,0x6F,0x77,0x65,0x76,0x65,0x72,0x2C,0x20,0x77,
-	0x69,0x6C,0x6C,0x20,0x69,0x6E,0x74,0x72,0x6F,0x64,0x75,0x63,
-	0x65,0x20,0x73,0x74,0x75,0x74,0x74,0x65,0x72,0x69,0x6E,0x67,
-	0x20,0x62,0x65,0x63,0x61,0x75,0x73,0x65,0x20,0x74,0x68,0x65,
-	0x20,0x72,0x65,0x6E,0x64,0x65,0x72,0x69,0x6E,0x67,0x20,0x72,
-	0x61,0x74,0x65,0x20,0x69,0x73,0x22,0x3E,0x6E,0x6F,0x74,0x20,
-	0x65,0x78,0x61,0x63,0x74,0x20,0x74,0x6F,0x20,0x79,0x6F,0x75,
-	0x72,0x20,0x6D,0x6F,0x6E,0x69,0x74,0x6F,0x72,0x27,0x73,0x20,
-	0x72,0x61,0x74,0x65,0x2E,0x06,0x3E,0x40,0x58,0x30,0x32,0x30,
-	0x33,0x3E,0x40,0x43,0x30,0x30,0x31,0x51,0x3A,0x20,0x57,0x69,
-	0x6C,0x6C,0x20,0x79,0x6F,0x75,0x20,0x69,0x6D,0x70,0x6C,0x65,
-	0x6D,0x65,0x6E,0x74,0x20,0x4D,0x49,0x44,0x49,0x20,0x6F,0x75,
-	0x74,0x20,0x66,0x75,0x6E,0x63,0x74,0x69,0x6F,0x6E,0x61,0x6C,
-	0x69,0x74,0x79,0x3F,0x4D,0x3E,0x40,0x43,0x30,0x30,0x32,0x41,
-	0x3A,0x20,0x4E,0x6F,0x2C,0x20,0x73,0x6F,0x72,0x72,0x79,0x2E,
-	0x20,0x54,0x68,0x69,0x73,0x20,0x69,0x73,0x20,0x76,0x65,0x72,
-	0x79,0x20,0x64,0x69,0x66,0x66,0x69,0x63,0x75,0x6C,0x74,0x20,
-	0x74,0x6F,0x20,0x69,0x6D,0x70,0x6C,0x65,0x6D,0x65,0x6E,0x74,
-	0x20,0x63,0x6F,0x72,0x72,0x65,0x63,0x74,0x6C,0x79,0x20,0x77,
-	0x68,0x65,0x6E,0x20,0x68,0x61,0x76,0x69,0x6E,0x67,0x3C,0x3E,
-	0x40,0x58,0x30,0x33,0x35,0x68,0x69,0x67,0x68,0x65,0x72,0x20,
-	0x61,0x75,0x64,0x69,0x6F,0x20,0x62,0x75,0x66,0x66,0x65,0x72,
-	0x20,0x73,0x69,0x7A,0x65,0x73,0x20,0x28,0x62,0x75,0x66,0x66,
-	0x65,0x72,0x65,0x64,0x20,0x72,0x65,0x70,0x6C,0x61,0x79,0x65,
-	0x72,0x20,0x74,0x69,0x63,0x6B,0x73,0x29,0x2E,0x2E,0x2E,0x06,
-	0x3E,0x40,0x58,0x30,0x32,0x30,0x30,0x3E,0x40,0x43,0x30,0x30,
-	0x31,0x51,0x3A,0x20,0x57,0x68,0x65,0x72,0x65,0x20,0x69,0x73,
-	0x20,0x74,0x68,0x65,0x20,0x63,0x6F,0x6E,0x66,0x69,0x67,0x75,
-	0x72,0x61,0x74,0x69,0x6F,0x6E,0x20,0x66,0x69,0x6C,0x65,0x20,
-	0x73,0x74,0x6F,0x72,0x65,0x64,0x3F,0x3F,0x3E,0x40,0x43,0x30,
-	0x30,0x32,0x41,0x3A,0x20,0x57,0x69,0x6E,0x64,0x6F,0x77,0x73,
-	0x3A,0x20,0x5C,0x55,0x73,0x65,0x72,0x73,0x5C,0x55,0x53,0x45,
-	0x52,0x5C,0x41,0x70,0x70,0x44,0x61,0x74,0x61,0x5C,0x52,0x6F,
-	0x61,0x6D,0x69,0x6E,0x67,0x5C,0x46,0x54,0x32,0x20,0x63,0x6C,
-	0x6F,0x6E,0x65,0x5C,0x46,0x54,0x32,0x2E,0x43,0x46,0x47,0x45,
-	0x3E,0x40,0x58,0x30,0x33,0x35,0x4F,0x53,0x20,0x58,0x3A,0x20,
-	0x2F,0x55,0x73,0x65,0x72,0x73,0x2F,0x55,0x53,0x45,0x52,0x2F,
-	0x4C,0x69,0x62,0x72,0x61,0x72,0x79,0x2F,0x41,0x70,0x70,0x6C,
-	0x69,0x63,0x61,0x74,0x69,0x6F,0x6E,0x20,0x53,0x75,0x70,0x70,
-	0x6F,0x72,0x74,0x2F,0x46,0x54,0x32,0x20,0x63,0x6C,0x6F,0x6E,
-	0x65,0x2F,0x46,0x54,0x32,0x2E,0x43,0x46,0x47,0x2F,0x47,0x4E,
-	0x55,0x2F,0x4C,0x69,0x6E,0x75,0x78,0x3A,0x20,0x2F,0x68,0x6F,
-	0x6D,0x65,0x2F,0x55,0x53,0x45,0x52,0x2F,0x2E,0x63,0x6F,0x6E,
-	0x66,0x69,0x67,0x2F,0x46,0x54,0x32,0x20,0x63,0x6C,0x6F,0x6E,
-	0x65,0x2F,0x46,0x54,0x32,0x2E,0x43,0x46,0x47,0x01,0x3E,0x48,
-	0x49,0x74,0x20,0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x73,
-	0x74,0x6F,0x72,0x65,0x64,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,
-	0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x20,0x64,0x69,0x72,
-	0x65,0x63,0x74,0x6F,0x72,0x79,0x20,0x69,0x66,0x20,0x74,0x68,
-	0x65,0x20,0x70,0x61,0x74,0x68,0x20,0x63,0x6F,0x75,0x6C,0x64,
-	0x6E,0x27,0x74,0x20,0x62,0x65,0x20,0x75,0x73,0x65,0x64,0x2E,
-	0x4D,0x49,0x66,0x20,0x79,0x6F,0x75,0x20,0x70,0x75,0x74,0x20,
-	0x74,0x68,0x65,0x20,0x63,0x6F,0x6E,0x66,0x69,0x67,0x75,0x72,
-	0x61,0x74,0x69,0x6F,0x6E,0x20,0x66,0x69,0x6C,0x65,0x20,0x69,
-	0x6E,0x20,0x74,0x68,0x65,0x20,0x70,0x72,0x6F,0x67,0x72,0x61,
-	0x6D,0x20,0x64,0x69,0x72,0x65,0x63,0x74,0x6F,0x72,0x79,0x2C,
-	0x20,0x69,0x74,0x20,0x77,0x69,0x6C,0x6C,0x20,0x72,0x65,0x61,
-	0x64,0x20,0x74,0x68,0x61,0x74,0x4A,0x6F,0x6E,0x65,0x20,0x61,
-	0x6E,0x64,0x20,0x6E,0x6F,0x74,0x20,0x61,0x74,0x74,0x65,0x6D,
-	0x70,0x74,0x20,0x74,0x6F,0x20,0x63,0x72,0x65,0x61,0x74,0x65,
-	0x20,0x63,0x6F,0x6E,0x66,0x69,0x67,0x20,0x64,0x69,0x72,0x73,
-	0x20,0x66,0x6F,0x72,0x20,0x74,0x68,0x65,0x20,0x4F,0x53,0x20,
-	0x75,0x73,0x65,0x72,0x2E,0x20,0x28,0x70,0x6F,0x72,0x74,0x61,
-	0x62,0x6C,0x65,0x20,0x6D,0x6F,0x64,0x65,0x29,0x06,0x3E,0x40,
-	0x58,0x30,0x32,0x30,0x42,0x3E,0x40,0x43,0x30,0x30,0x31,0x51,
-	0x3A,0x20,0x43,0x61,0x6E,0x20,0x74,0x68,0x65,0x20,0x63,0x6C,
-	0x6F,0x6E,0x65,0x20,0x72,0x65,0x61,0x64,0x20,0x46,0x54,0x32,
-	0x2E,0x43,0x46,0x47,0x20,0x66,0x72,0x6F,0x6D,0x20,0x72,0x65,
-	0x61,0x6C,0x20,0x46,0x54,0x32,0x2C,0x20,0x61,0x6E,0x64,0x20,
-	0x76,0x69,0x63,0x65,0x20,0x76,0x65,0x72,0x73,0x61,0x3F,0x4C,
-	0x3E,0x40,0x43,0x30,0x30,0x32,0x41,0x3A,0x20,0x59,0x65,0x73,
-	0x2C,0x20,0x69,0x74,0x20,0x73,0x68,0x6F,0x75,0x6C,0x64,0x20,
-	0x77,0x6F,0x72,0x6B,0x20,0x6A,0x75,0x73,0x74,0x20,0x66,0x69,
-	0x6E,0x65,0x2E,0x20,0x50,0x75,0x74,0x20,0x69,0x74,0x20,0x69,
-	0x6E,0x20,0x74,0x68,0x65,0x20,0x64,0x69,0x72,0x65,0x63,0x74,
-	0x6F,0x72,0x79,0x20,0x73,0x68,0x6F,0x77,0x6E,0x20,0x61,0x62,
-	0x6F,0x76,0x65,0x2E,0x06,0x3E,0x40,0x58,0x30,0x32,0x30,0x52,
-	0x3E,0x40,0x43,0x30,0x30,0x31,0x51,0x3A,0x20,0x53,0x6D,0x70,
-	0x2E,0x20,0x45,0x64,0x2E,0x3A,0x20,0x57,0x68,0x69,0x6C,0x65,
-	0x20,0x7A,0x6F,0x6F,0x6D,0x69,0x6E,0x67,0x20,0x69,0x6E,0x2C,
-	0x20,0x49,0x20,0x73,0x6F,0x6D,0x65,0x74,0x69,0x6D,0x65,0x73,
-	0x20,0x63,0x61,0x6E,0x27,0x74,0x20,0x6D,0x61,0x72,0x6B,0x20,
-	0x74,0x68,0x65,0x20,0x6C,0x61,0x73,0x74,0x20,0x73,0x61,0x6D,
-	0x70,0x6C,0x65,0x20,0x70,0x6F,0x69,0x6E,0x74,0x21,0x47,0x3E,
-	0x40,0x43,0x30,0x30,0x32,0x41,0x3A,0x20,0x54,0x68,0x69,0x73,
-	0x20,0x69,0x73,0x20,0x6E,0x6F,0x72,0x6D,0x61,0x6C,0x2E,0x20,
-	0x54,0x68,0x69,0x73,0x20,0x69,0x73,0x20,0x61,0x20,0x6C,0x69,
-	0x6D,0x69,0x74,0x61,0x74,0x69,0x6F,0x6E,0x20,0x69,0x6E,0x20,
-	0x74,0x68,0x65,0x20,0x6E,0x61,0x74,0x75,0x72,0x65,0x20,0x6F,
-	0x66,0x20,0x73,0x63,0x61,0x6C,0x69,0x6E,0x67,0x2E,0x06,0x3E,
-	0x40,0x58,0x30,0x32,0x30,0x17,0x3E,0x40,0x43,0x30,0x30,0x31,
-	0x51,0x3A,0x20,0x49,0x20,0x66,0x6F,0x75,0x6E,0x64,0x20,0x61,
-	0x20,0x62,0x75,0x67,0x21,0x4C,0x3E,0x40,0x43,0x30,0x30,0x32,
-	0x41,0x3A,0x20,0x50,0x6C,0x65,0x61,0x73,0x65,0x20,0x73,0x65,
-	0x6E,0x64,0x20,0x6D,0x65,0x20,0x61,0x20,0x6D,0x61,0x69,0x6C,
-	0x20,0x28,0x66,0x6F,0x75,0x6E,0x64,0x20,0x61,0x74,0x20,0x31,
-	0x36,0x2D,0x62,0x69,0x74,0x73,0x2E,0x6F,0x72,0x67,0x29,0x20,
-	0x61,0x6E,0x64,0x20,0x74,0x72,0x79,0x20,0x74,0x6F,0x20,0x65,
-	0x78,0x70,0x6C,0x61,0x69,0x6E,0x20,0x69,0x74,0x2E,0x00,0x03,
-	0x45,0x4E,0x44,0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
+	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x0E,0x40,0x4C,0x50,0x72,
+	0x6F,0x62,0x6C,0x65,0x6D,0x73,0x2F,0x46,0x41,0x51,0x06,0x3E,
+	0x40,0x58,0x30,0x32,0x30,0x2A,0x3E,0x40,0x43,0x30,0x30,0x31,
+	0x51,0x3A,0x20,0x48,0x6F,0x77,0x20,0x63,0x61,0x6E,0x20,0x49,
+	0x20,0x74,0x6F,0x67,0x67,0x6C,0x65,0x20,0x66,0x75,0x6C,0x6C,
+	0x73,0x63,0x72,0x65,0x65,0x6E,0x20,0x6D,0x6F,0x64,0x65,0x3F,
+	0x37,0x3E,0x40,0x43,0x30,0x30,0x32,0x41,0x3A,0x20,0x50,0x72,
+	0x65,0x73,0x73,0x20,0x41,0x6C,0x74,0x2B,0x45,0x6E,0x74,0x65,
+	0x72,0x20,0x28,0x43,0x74,0x72,0x6C,0x2B,0x43,0x6D,0x64,0x2B,
+	0x46,0x20,0x61,0x6C,0x73,0x6F,0x20,0x77,0x6F,0x72,0x6B,0x73,
+	0x20,0x6F,0x6E,0x20,0x4D,0x61,0x63,0x29,0x06,0x3E,0x40,0x58,
+	0x30,0x32,0x30,0x45,0x3E,0x40,0x43,0x30,0x30,0x31,0x51,0x3A,
+	0x20,0x48,0x6F,0x77,0x20,0x63,0x61,0x6E,0x20,0x49,0x20,0x6D,
+	0x61,0x6B,0x65,0x20,0x66,0x75,0x6C,0x6C,0x73,0x63,0x72,0x65,
+	0x65,0x6E,0x20,0x6D,0x6F,0x64,0x65,0x20,0x73,0x74,0x72,0x65,
+	0x74,0x63,0x68,0x20,0x6F,0x75,0x74,0x20,0x74,0x68,0x65,0x20,
+	0x77,0x68,0x6F,0x6C,0x65,0x20,0x73,0x63,0x72,0x65,0x65,0x6E,
+	0x3F,0x37,0x3E,0x40,0x43,0x30,0x30,0x32,0x41,0x3A,0x20,0x45,
+	0x6E,0x61,0x62,0x6C,0x65,0x20,0x22,0x53,0x74,0x72,0x65,0x74,
+	0x63,0x68,0x65,0x64,0x22,0x20,0x69,0x6E,0x20,0x43,0x6F,0x6E,
+	0x66,0x69,0x67,0x20,0x2D,0x3E,0x20,0x4D,0x69,0x73,0x63,0x65,
+	0x6C,0x6C,0x61,0x6E,0x65,0x6F,0x75,0x73,0x2E,0x4E,0x3E,0x40,
+	0x58,0x30,0x33,0x35,0x54,0x68,0x69,0x73,0x20,0x77,0x69,0x6C,
+	0x6C,0x20,0x72,0x65,0x73,0x75,0x6C,0x74,0x20,0x69,0x6E,0x20,
+	0x75,0x6E,0x65,0x76,0x65,0x6E,0x20,0x70,0x69,0x78,0x65,0x6C,
+	0x20,0x77,0x69,0x64,0x74,0x68,0x73,0x2E,0x20,0x49,0x66,0x20,
+	0x79,0x6F,0x75,0x20,0x77,0x61,0x6E,0x74,0x20,0x74,0x6F,0x20,
+	0x66,0x69,0x78,0x20,0x74,0x68,0x69,0x73,0x2C,0x20,0x65,0x6E,
+	0x61,0x62,0x6C,0x65,0x3D,0x22,0x50,0x69,0x78,0x65,0x6C,0x20,
+	0x66,0x69,0x6C,0x74,0x65,0x72,0x22,0x20,0x28,0x74,0x68,0x6F,
+	0x75,0x67,0x68,0x20,0x74,0x68,0x69,0x73,0x20,0x77,0x69,0x6C,
+	0x6C,0x20,0x6D,0x61,0x6B,0x65,0x20,0x74,0x68,0x65,0x20,0x69,
+	0x6D,0x61,0x67,0x65,0x20,0x6C,0x6F,0x6F,0x6B,0x20,0x62,0x6C,
+	0x75,0x72,0x72,0x79,0x29,0x2E,0x06,0x3E,0x40,0x58,0x30,0x32,
+	0x30,0x27,0x3E,0x40,0x43,0x30,0x30,0x31,0x51,0x3A,0x20,0x49,
+	0x20,0x63,0x61,0x6E,0x27,0x74,0x20,0x75,0x73,0x65,0x20,0x41,
+	0x6C,0x74,0x2B,0x46,0x34,0x20,0x61,0x6E,0x64,0x20,0x41,0x6C,
+	0x74,0x2B,0x46,0x35,0x21,0x4E,0x3E,0x40,0x43,0x30,0x30,0x32,
+	0x41,0x3A,0x20,0x57,0x69,0x6E,0x64,0x6F,0x77,0x73,0x3A,0x20,
+	0x49,0x66,0x20,0x79,0x6F,0x75,0x20,0x68,0x61,0x76,0x65,0x20,
+	0x47,0x65,0x46,0x6F,0x72,0x63,0x65,0x20,0x45,0x78,0x70,0x65,
+	0x72,0x69,0x65,0x6E,0x63,0x65,0x20,0x69,0x6E,0x73,0x74,0x61,
+	0x6C,0x6C,0x65,0x64,0x2C,0x20,0x79,0x6F,0x75,0x20,0x6E,0x65,
+	0x65,0x64,0x20,0x74,0x6F,0x20,0x63,0x68,0x61,0x6E,0x67,0x65,
+	0x2B,0x3E,0x40,0x58,0x30,0x33,0x35,0x74,0x68,0x65,0x20,0x6B,
+	0x65,0x79,0x62,0x69,0x6E,0x64,0x69,0x6E,0x67,0x73,0x20,0x69,
+	0x6E,0x20,0x69,0x74,0x73,0x20,0x73,0x65,0x74,0x74,0x69,0x6E,
+	0x67,0x73,0x20,0x70,0x61,0x67,0x65,0x2E,0x57,0x3E,0x6D,0x61,
+	0x63,0x4F,0x53,0x2F,0x4F,0x53,0x20,0x58,0x3A,0x20,0x43,0x68,
+	0x61,0x6E,0x67,0x65,0x20,0x41,0x6C,0x74,0x2B,0x46,0x34,0x2F,
+	0x41,0x6C,0x74,0x2B,0x46,0x35,0x20,0x6B,0x65,0x79,0x73,0x20,
+	0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x4F,0x53,0x20,0x74,0x6F,
+	0x20,0x73,0x6F,0x6D,0x65,0x74,0x68,0x69,0x6E,0x67,0x20,0x65,
+	0x6C,0x73,0x65,0x2E,0x20,0x41,0x6C,0x73,0x6F,0x20,0x66,0x6F,
+	0x72,0x20,0x47,0x4E,0x55,0x2F,0x4C,0x69,0x6E,0x75,0x78,0x2E,
+	0x06,0x3E,0x40,0x58,0x30,0x32,0x30,0x2B,0x3E,0x40,0x43,0x30,
+	0x30,0x31,0x51,0x3A,0x20,0x54,0x68,0x65,0x20,0x6D,0x6F,0x75,
+	0x73,0x65,0x20,0x63,0x75,0x72,0x73,0x6F,0x72,0x20,0x69,0x73,
+	0x20,0x64,0x65,0x6C,0x61,0x79,0x65,0x64,0x2F,0x6C,0x61,0x67,
+	0x67,0x79,0x21,0x44,0x3E,0x40,0x43,0x30,0x30,0x32,0x41,0x3A,
+	0x20,0x4D,0x61,0x6B,0x65,0x20,0x73,0x75,0x72,0x65,0x20,0x22,
+	0x53,0x6F,0x66,0x74,0x77,0x61,0x72,0x65,0x20,0x6D,0x6F,0x75,
+	0x73,0x65,0x22,0x20,0x69,0x73,0x20,0x64,0x69,0x73,0x61,0x62,
+	0x6C,0x65,0x64,0x20,0x69,0x6E,0x20,0x43,0x6F,0x6E,0x66,0x69,
+	0x67,0x20,0x2D,0x3E,0x20,0x4C,0x61,0x79,0x6F,0x75,0x74,0x2E,
+	0x4B,0x3E,0x40,0x58,0x30,0x33,0x35,0x41,0x6C,0x74,0x65,0x72,
+	0x6E,0x61,0x74,0x69,0x76,0x65,0x6C,0x79,0x2C,0x20,0x79,0x6F,
+	0x75,0x20,0x63,0x61,0x6E,0x20,0x65,0x6E,0x61,0x62,0x6C,0x65,
+	0x20,0x22,0x56,0x53,0x79,0x6E,0x63,0x20,0x6F,0x66,0x66,0x22,
+	0x20,0x69,0x6E,0x20,0x43,0x6F,0x6E,0x66,0x69,0x67,0x20,0x2D,
+	0x3E,0x20,0x4D,0x69,0x73,0x63,0x65,0x6C,0x6C,0x61,0x6E,0x65,
+	0x6F,0x75,0x73,0x2E,0x46,0x3E,0x54,0x68,0x69,0x73,0x20,0x68,
+	0x6F,0x77,0x65,0x76,0x65,0x72,0x2C,0x20,0x77,0x69,0x6C,0x6C,
+	0x20,0x69,0x6E,0x74,0x72,0x6F,0x64,0x75,0x63,0x65,0x20,0x73,
+	0x74,0x75,0x74,0x74,0x65,0x72,0x69,0x6E,0x67,0x20,0x62,0x65,
+	0x63,0x61,0x75,0x73,0x65,0x20,0x74,0x68,0x65,0x20,0x72,0x65,
+	0x6E,0x64,0x65,0x72,0x69,0x6E,0x67,0x20,0x72,0x61,0x74,0x65,
+	0x20,0x69,0x73,0x22,0x3E,0x6E,0x6F,0x74,0x20,0x65,0x78,0x61,
+	0x63,0x74,0x20,0x74,0x6F,0x20,0x79,0x6F,0x75,0x72,0x20,0x6D,
+	0x6F,0x6E,0x69,0x74,0x6F,0x72,0x27,0x73,0x20,0x72,0x61,0x74,
+	0x65,0x2E,0x06,0x3E,0x40,0x58,0x30,0x32,0x30,0x33,0x3E,0x40,
+	0x43,0x30,0x30,0x31,0x51,0x3A,0x20,0x57,0x69,0x6C,0x6C,0x20,
+	0x79,0x6F,0x75,0x20,0x69,0x6D,0x70,0x6C,0x65,0x6D,0x65,0x6E,
+	0x74,0x20,0x4D,0x49,0x44,0x49,0x20,0x6F,0x75,0x74,0x20,0x66,
+	0x75,0x6E,0x63,0x74,0x69,0x6F,0x6E,0x61,0x6C,0x69,0x74,0x79,
+	0x3F,0x4D,0x3E,0x40,0x43,0x30,0x30,0x32,0x41,0x3A,0x20,0x4E,
+	0x6F,0x2C,0x20,0x73,0x6F,0x72,0x72,0x79,0x2E,0x20,0x54,0x68,
+	0x69,0x73,0x20,0x69,0x73,0x20,0x76,0x65,0x72,0x79,0x20,0x64,
+	0x69,0x66,0x66,0x69,0x63,0x75,0x6C,0x74,0x20,0x74,0x6F,0x20,
+	0x69,0x6D,0x70,0x6C,0x65,0x6D,0x65,0x6E,0x74,0x20,0x63,0x6F,
+	0x72,0x72,0x65,0x63,0x74,0x6C,0x79,0x20,0x77,0x68,0x65,0x6E,
+	0x20,0x68,0x61,0x76,0x69,0x6E,0x67,0x3C,0x3E,0x40,0x58,0x30,
+	0x33,0x35,0x68,0x69,0x67,0x68,0x65,0x72,0x20,0x61,0x75,0x64,
+	0x69,0x6F,0x20,0x62,0x75,0x66,0x66,0x65,0x72,0x20,0x73,0x69,
+	0x7A,0x65,0x73,0x20,0x28,0x62,0x75,0x66,0x66,0x65,0x72,0x65,
+	0x64,0x20,0x72,0x65,0x70,0x6C,0x61,0x79,0x65,0x72,0x20,0x74,
+	0x69,0x63,0x6B,0x73,0x29,0x2E,0x2E,0x2E,0x06,0x3E,0x40,0x58,
+	0x30,0x32,0x30,0x30,0x3E,0x40,0x43,0x30,0x30,0x31,0x51,0x3A,
+	0x20,0x57,0x68,0x65,0x72,0x65,0x20,0x69,0x73,0x20,0x74,0x68,
+	0x65,0x20,0x63,0x6F,0x6E,0x66,0x69,0x67,0x75,0x72,0x61,0x74,
+	0x69,0x6F,0x6E,0x20,0x66,0x69,0x6C,0x65,0x20,0x73,0x74,0x6F,
+	0x72,0x65,0x64,0x3F,0x3F,0x3E,0x40,0x43,0x30,0x30,0x32,0x41,
+	0x3A,0x20,0x57,0x69,0x6E,0x64,0x6F,0x77,0x73,0x3A,0x20,0x5C,
+	0x55,0x73,0x65,0x72,0x73,0x5C,0x55,0x53,0x45,0x52,0x5C,0x41,
+	0x70,0x70,0x44,0x61,0x74,0x61,0x5C,0x52,0x6F,0x61,0x6D,0x69,
+	0x6E,0x67,0x5C,0x46,0x54,0x32,0x20,0x63,0x6C,0x6F,0x6E,0x65,
+	0x5C,0x46,0x54,0x32,0x2E,0x43,0x46,0x47,0x45,0x3E,0x40,0x58,
+	0x30,0x33,0x35,0x4F,0x53,0x20,0x58,0x3A,0x20,0x2F,0x55,0x73,
+	0x65,0x72,0x73,0x2F,0x55,0x53,0x45,0x52,0x2F,0x4C,0x69,0x62,
+	0x72,0x61,0x72,0x79,0x2F,0x41,0x70,0x70,0x6C,0x69,0x63,0x61,
+	0x74,0x69,0x6F,0x6E,0x20,0x53,0x75,0x70,0x70,0x6F,0x72,0x74,
+	0x2F,0x46,0x54,0x32,0x20,0x63,0x6C,0x6F,0x6E,0x65,0x2F,0x46,
+	0x54,0x32,0x2E,0x43,0x46,0x47,0x2F,0x47,0x4E,0x55,0x2F,0x4C,
+	0x69,0x6E,0x75,0x78,0x3A,0x20,0x2F,0x68,0x6F,0x6D,0x65,0x2F,
+	0x55,0x53,0x45,0x52,0x2F,0x2E,0x63,0x6F,0x6E,0x66,0x69,0x67,
+	0x2F,0x46,0x54,0x32,0x20,0x63,0x6C,0x6F,0x6E,0x65,0x2F,0x46,
+	0x54,0x32,0x2E,0x43,0x46,0x47,0x01,0x3E,0x48,0x49,0x74,0x20,
+	0x77,0x69,0x6C,0x6C,0x20,0x62,0x65,0x20,0x73,0x74,0x6F,0x72,
+	0x65,0x64,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x70,0x72,
+	0x6F,0x67,0x72,0x61,0x6D,0x20,0x64,0x69,0x72,0x65,0x63,0x74,
+	0x6F,0x72,0x79,0x20,0x69,0x66,0x20,0x74,0x68,0x65,0x20,0x70,
+	0x61,0x74,0x68,0x20,0x63,0x6F,0x75,0x6C,0x64,0x6E,0x27,0x74,
+	0x20,0x62,0x65,0x20,0x75,0x73,0x65,0x64,0x2E,0x4D,0x49,0x66,
+	0x20,0x79,0x6F,0x75,0x20,0x70,0x75,0x74,0x20,0x74,0x68,0x65,
+	0x20,0x63,0x6F,0x6E,0x66,0x69,0x67,0x75,0x72,0x61,0x74,0x69,
+	0x6F,0x6E,0x20,0x66,0x69,0x6C,0x65,0x20,0x69,0x6E,0x20,0x74,
+	0x68,0x65,0x20,0x70,0x72,0x6F,0x67,0x72,0x61,0x6D,0x20,0x64,
+	0x69,0x72,0x65,0x63,0x74,0x6F,0x72,0x79,0x2C,0x20,0x69,0x74,
+	0x20,0x77,0x69,0x6C,0x6C,0x20,0x72,0x65,0x61,0x64,0x20,0x74,
+	0x68,0x61,0x74,0x4A,0x6F,0x6E,0x65,0x20,0x61,0x6E,0x64,0x20,
+	0x6E,0x6F,0x74,0x20,0x61,0x74,0x74,0x65,0x6D,0x70,0x74,0x20,
+	0x74,0x6F,0x20,0x63,0x72,0x65,0x61,0x74,0x65,0x20,0x63,0x6F,
+	0x6E,0x66,0x69,0x67,0x20,0x64,0x69,0x72,0x73,0x20,0x66,0x6F,
+	0x72,0x20,0x74,0x68,0x65,0x20,0x4F,0x53,0x20,0x75,0x73,0x65,
+	0x72,0x2E,0x20,0x28,0x70,0x6F,0x72,0x74,0x61,0x62,0x6C,0x65,
+	0x20,0x6D,0x6F,0x64,0x65,0x29,0x06,0x3E,0x40,0x58,0x30,0x32,
+	0x30,0x42,0x3E,0x40,0x43,0x30,0x30,0x31,0x51,0x3A,0x20,0x43,
+	0x61,0x6E,0x20,0x74,0x68,0x65,0x20,0x63,0x6C,0x6F,0x6E,0x65,
+	0x20,0x72,0x65,0x61,0x64,0x20,0x46,0x54,0x32,0x2E,0x43,0x46,
+	0x47,0x20,0x66,0x72,0x6F,0x6D,0x20,0x72,0x65,0x61,0x6C,0x20,
+	0x46,0x54,0x32,0x2C,0x20,0x61,0x6E,0x64,0x20,0x76,0x69,0x63,
+	0x65,0x20,0x76,0x65,0x72,0x73,0x61,0x3F,0x4C,0x3E,0x40,0x43,
+	0x30,0x30,0x32,0x41,0x3A,0x20,0x59,0x65,0x73,0x2C,0x20,0x69,
+	0x74,0x20,0x73,0x68,0x6F,0x75,0x6C,0x64,0x20,0x77,0x6F,0x72,
+	0x6B,0x20,0x6A,0x75,0x73,0x74,0x20,0x66,0x69,0x6E,0x65,0x2E,
+	0x20,0x50,0x75,0x74,0x20,0x69,0x74,0x20,0x69,0x6E,0x20,0x74,
+	0x68,0x65,0x20,0x64,0x69,0x72,0x65,0x63,0x74,0x6F,0x72,0x79,
+	0x20,0x73,0x68,0x6F,0x77,0x6E,0x20,0x61,0x62,0x6F,0x76,0x65,
+	0x2E,0x06,0x3E,0x40,0x58,0x30,0x32,0x30,0x52,0x3E,0x40,0x43,
+	0x30,0x30,0x31,0x51,0x3A,0x20,0x53,0x6D,0x70,0x2E,0x20,0x45,
+	0x64,0x2E,0x3A,0x20,0x57,0x68,0x69,0x6C,0x65,0x20,0x7A,0x6F,
+	0x6F,0x6D,0x69,0x6E,0x67,0x20,0x69,0x6E,0x2C,0x20,0x49,0x20,
+	0x73,0x6F,0x6D,0x65,0x74,0x69,0x6D,0x65,0x73,0x20,0x63,0x61,
+	0x6E,0x27,0x74,0x20,0x6D,0x61,0x72,0x6B,0x20,0x74,0x68,0x65,
+	0x20,0x6C,0x61,0x73,0x74,0x20,0x73,0x61,0x6D,0x70,0x6C,0x65,
+	0x20,0x70,0x6F,0x69,0x6E,0x74,0x21,0x47,0x3E,0x40,0x43,0x30,
+	0x30,0x32,0x41,0x3A,0x20,0x54,0x68,0x69,0x73,0x20,0x69,0x73,
+	0x20,0x6E,0x6F,0x72,0x6D,0x61,0x6C,0x2E,0x20,0x54,0x68,0x69,
+	0x73,0x20,0x69,0x73,0x20,0x61,0x20,0x6C,0x69,0x6D,0x69,0x74,
+	0x61,0x74,0x69,0x6F,0x6E,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,
+	0x20,0x6E,0x61,0x74,0x75,0x72,0x65,0x20,0x6F,0x66,0x20,0x73,
+	0x63,0x61,0x6C,0x69,0x6E,0x67,0x2E,0x06,0x3E,0x40,0x58,0x30,
+	0x32,0x30,0x17,0x3E,0x40,0x43,0x30,0x30,0x31,0x51,0x3A,0x20,
+	0x49,0x20,0x66,0x6F,0x75,0x6E,0x64,0x20,0x61,0x20,0x62,0x75,
+	0x67,0x21,0x4C,0x3E,0x40,0x43,0x30,0x30,0x32,0x41,0x3A,0x20,
+	0x50,0x6C,0x65,0x61,0x73,0x65,0x20,0x73,0x65,0x6E,0x64,0x20,
+	0x6D,0x65,0x20,0x61,0x20,0x6D,0x61,0x69,0x6C,0x20,0x28,0x66,
+	0x6F,0x75,0x6E,0x64,0x20,0x61,0x74,0x20,0x31,0x36,0x2D,0x62,
+	0x69,0x74,0x73,0x2E,0x6F,0x72,0x67,0x29,0x20,0x61,0x6E,0x64,
+	0x20,0x74,0x72,0x79,0x20,0x74,0x6F,0x20,0x65,0x78,0x70,0x6C,
+	0x61,0x69,0x6E,0x20,0x69,0x74,0x2E,0x00,0x03,0x45,0x4E,0x44,
+	0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
-	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x4C,0x3B,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
+	0x2A,0x2A,0x2A,0x2A,0x2A,0x4C,0x3B,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
 	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,
-	0x2A,0x0C,0x40,0x4C,0x4B,0x6E,0x6F,0x77,0x6E,0x20,0x62,0x75,
+	0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x2A,0x0C,0x40,
-	0x67,0x73,0x06,0x3E,0x40,0x58,0x30,0x31,0x30,0x2C,0x3E,0x40,
+	0x4C,0x4B,0x6E,0x6F,0x77,0x6E,0x20,0x62,0x75,0x67,0x73,0x06,
-	0x43,0x30,0x30,0x31,0x57,0x41,0x56,0x20,0x65,0x78,0x70,0x6F,
+	0x3E,0x40,0x58,0x30,0x31,0x30,0x2C,0x3E,0x40,0x43,0x30,0x30,
-	0x72,0x74,0x69,0x6E,0x67,0x20,0x28,0x72,0x65,0x6E,0x64,0x65,
+	0x31,0x57,0x41,0x56,0x20,0x65,0x78,0x70,0x6F,0x72,0x74,0x69,
-	0x72,0x69,0x6E,0x67,0x20,0x73,0x6F,0x6E,0x67,0x20,0x74,0x6F,
+	0x6E,0x67,0x20,0x28,0x72,0x65,0x6E,0x64,0x65,0x72,0x69,0x6E,
-	0x20,0x57,0x41,0x56,0x29,0x3A,0x01,0x3E,0x50,0x3E,0x40,0x43,
+	0x67,0x20,0x73,0x6F,0x6E,0x67,0x20,0x74,0x6F,0x20,0x57,0x41,
-	0x30,0x30,0x32,0x2D,0x20,0x53,0x6F,0x6E,0x67,0x73,0x20,0x74,
+	0x56,0x29,0x3A,0x01,0x3E,0x50,0x3E,0x40,0x43,0x30,0x30,0x32,
-	0x68,0x61,0x74,0x20,0x6A,0x75,0x6D,0x70,0x20,0x62,0x61,0x63,
+	0x2D,0x20,0x53,0x6F,0x6E,0x67,0x73,0x20,0x74,0x68,0x61,0x74,
-	0x6B,0x20,0x74,0x6F,0x20,0x61,0x20,0x70,0x72,0x65,0x76,0x69,
+	0x20,0x6A,0x75,0x6D,0x70,0x20,0x62,0x61,0x63,0x6B,0x20,0x74,
-	0x6F,0x75,0x73,0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,
+	0x6F,0x20,0x61,0x20,0x70,0x72,0x65,0x76,0x69,0x6F,0x75,0x73,
-	0x77,0x69,0x6C,0x6C,0x20,0x72,0x65,0x6E,0x64,0x65,0x72,0x20,
+	0x20,0x70,0x61,0x74,0x74,0x65,0x72,0x6E,0x20,0x77,0x69,0x6C,
-	0x66,0x6F,0x72,0x65,0x76,0x65,0x72,0x20,0x61,0x6E,0x64,0x20,
+	0x6C,0x20,0x72,0x65,0x6E,0x64,0x65,0x72,0x20,0x66,0x6F,0x72,
-	0x65,0x76,0x65,0x72,0x2C,0x50,0x61,0x6E,0x64,0x20,0x79,0x6F,
+	0x65,0x76,0x65,0x72,0x20,0x61,0x6E,0x64,0x20,0x65,0x76,0x65,
-	0x75,0x20,0x6E,0x65,0x65,0x64,0x20,0x74,0x6F,0x20,0x70,0x72,
+	0x72,0x2C,0x50,0x61,0x6E,0x64,0x20,0x79,0x6F,0x75,0x20,0x6E,
-	0x65,0x73,0x73,0x20,0x61,0x20,0x6B,0x65,0x79,0x20,0x6F,0x72,
+	0x65,0x65,0x64,0x20,0x74,0x6F,0x20,0x70,0x72,0x65,0x73,0x73,
-	0x20,0x63,0x6C,0x69,0x63,0x6B,0x20,0x74,0x68,0x65,0x20,0x6D,
+	0x20,0x61,0x20,0x6B,0x65,0x79,0x20,0x6F,0x72,0x20,0x63,0x6C,
-	0x6F,0x75,0x73,0x65,0x20,0x74,0x6F,0x20,0x61,0x62,0x6F,0x72,
+	0x69,0x63,0x6B,0x20,0x74,0x68,0x65,0x20,0x6D,0x6F,0x75,0x73,
-	0x74,0x20,0x74,0x68,0x65,0x20,0x72,0x65,0x6E,0x64,0x65,0x72,
+	0x65,0x20,0x74,0x6F,0x20,0x61,0x62,0x6F,0x72,0x74,0x20,0x74,
-	0x20,0x77,0x68,0x65,0x6E,0x20,0x79,0x6F,0x75,0x20,0x77,0x61,
+	0x68,0x65,0x20,0x72,0x65,0x6E,0x64,0x65,0x72,0x20,0x77,0x68,
-	0x6E,0x74,0x06,0x69,0x74,0x20,0x74,0x6F,0x2E,0x06,0x3E,0x40,
+	0x65,0x6E,0x20,0x79,0x6F,0x75,0x20,0x77,0x61,0x6E,0x74,0x06,
-	0x58,0x30,0x31,0x30,0x17,0x3E,0x40,0x43,0x30,0x30,0x31,0x4D,
+	0x69,0x74,0x20,0x74,0x6F,0x2E,0x06,0x3E,0x40,0x58,0x30,0x31,
-	0x6F,0x75,0x73,0x65,0x20,0x2F,0x20,0x6B,0x65,0x79,0x62,0x6F,
+	0x30,0x17,0x3E,0x40,0x43,0x30,0x30,0x31,0x4D,0x6F,0x75,0x73,
-	0x61,0x72,0x64,0x3A,0x01,0x3E,0x43,0x3E,0x40,0x43,0x30,0x30,
+	0x65,0x20,0x2F,0x20,0x6B,0x65,0x79,0x62,0x6F,0x61,0x72,0x64,
-	0x32,0x2D,0x20,0x4C,0x69,0x6E,0x75,0x78,0x3A,0x20,0x54,0x68,
+	0x3A,0x01,0x3E,0x43,0x3E,0x40,0x43,0x30,0x30,0x32,0x2D,0x20,
-	0x65,0x20,0x6D,0x6F,0x75,0x73,0x65,0x20,0x63,0x75,0x72,0x73,
+	0x4C,0x69,0x6E,0x75,0x78,0x3A,0x20,0x54,0x68,0x65,0x20,0x6D,
-	0x6F,0x72,0x20,0x67,0x72,0x61,0x70,0x68,0x69,0x63,0x73,0x20,
+	0x6F,0x75,0x73,0x65,0x20,0x63,0x75,0x72,0x73,0x6F,0x72,0x20,
-	0x63,0x61,0x6E,0x20,0x62,0x65,0x20,0x67,0x6C,0x69,0x74,0x63,
+	0x67,0x72,0x61,0x70,0x68,0x69,0x63,0x73,0x20,0x63,0x61,0x6E,
-	0x68,0x79,0x20,0x61,0x74,0x20,0x74,0x69,0x6D,0x65,0x73,0x2E,
+	0x20,0x62,0x65,0x20,0x67,0x6C,0x69,0x74,0x63,0x68,0x79,0x20,
-	0x2E,0x2E,0x06,0x3E,0x40,0x58,0x30,0x31,0x30,0x0C,0x3E,0x40,
+	0x61,0x74,0x20,0x74,0x69,0x6D,0x65,0x73,0x2E,0x2E,0x2E,0x06,
-	0x43,0x30,0x30,0x31,0x56,0x69,0x64,0x65,0x6F,0x3A,0x06,0x3E,
+	0x3E,0x40,0x58,0x30,0x31,0x30,0x0C,0x3E,0x40,0x43,0x30,0x30,
-	0x40,0x43,0x30,0x30,0x32,0x50,0x3E,0x40,0x58,0x30,0x31,0x30,
+	0x31,0x56,0x69,0x64,0x65,0x6F,0x3A,0x06,0x3E,0x40,0x43,0x30,
-	0x2D,0x20,0x46,0x75,0x6C,0x6C,0x73,0x63,0x72,0x65,0x65,0x6E,
+	0x30,0x32,0x50,0x3E,0x40,0x58,0x30,0x31,0x30,0x2D,0x20,0x46,
-	0x20,0x6D,0x6F,0x64,0x65,0x20,0x63,0x61,0x6E,0x20,0x62,0x65,
+	0x75,0x6C,0x6C,0x73,0x63,0x72,0x65,0x65,0x6E,0x20,0x6D,0x6F,
-	0x20,0x75,0x6E,0x62,0x65,0x61,0x72,0x61,0x62,0x6C,0x79,0x20,
+	0x64,0x65,0x20,0x63,0x61,0x6E,0x20,0x62,0x65,0x20,0x75,0x6E,
-	0x73,0x6C,0x6F,0x77,0x20,0x6F,0x6E,0x20,0x61,0x20,0x52,0x61,
+	0x62,0x65,0x61,0x72,0x61,0x62,0x6C,0x79,0x20,0x73,0x6C,0x6F,
-	0x73,0x70,0x62,0x65,0x72,0x72,0x79,0x20,0x50,0x69,0x20,0x28,
+	0x77,0x20,0x6F,0x6E,0x20,0x61,0x20,0x52,0x61,0x73,0x70,0x62,
-	0x65,0x76,0x65,0x6E,0x20,0x6F,0x6E,0x20,0x52,0x50,0x69,0x20,
+	0x65,0x72,0x72,0x79,0x20,0x50,0x69,0x20,0x28,0x65,0x76,0x65,
-	0x34,0x29,0x01,0x3E,0x52,0x3E,0x40,0x58,0x30,0x31,0x30,0x2D,
+	0x6E,0x20,0x6F,0x6E,0x20,0x52,0x50,0x69,0x20,0x34,0x29,0x01,
-	0x20,0x4E,0x6F,0x74,0x20,0x61,0x20,0x62,0x75,0x67,0x2C,0x20,
+	0x3E,0x52,0x3E,0x40,0x58,0x30,0x31,0x30,0x2D,0x20,0x4E,0x6F,
-	0x62,0x75,0x74,0x20,0x69,0x66,0x20,0x79,0x6F,0x75,0x72,0x20,
+	0x74,0x20,0x61,0x20,0x62,0x75,0x67,0x2C,0x20,0x62,0x75,0x74,
-	0x6D,0x6F,0x6E,0x69,0x74,0x6F,0x72,0x27,0x73,0x20,0x72,0x65,
+	0x20,0x69,0x66,0x20,0x79,0x6F,0x75,0x72,0x20,0x6D,0x6F,0x6E,
-	0x66,0x72,0x65,0x73,0x68,0x20,0x72,0x61,0x74,0x65,0x20,0x69,
+	0x69,0x74,0x6F,0x72,0x27,0x73,0x20,0x72,0x65,0x66,0x72,0x65,
-	0x73,0x20,0x6E,0x6F,0x74,0x20,0x73,0x65,0x74,0x20,0x74,0x6F,
+	0x73,0x68,0x20,0x72,0x61,0x74,0x65,0x20,0x69,0x73,0x20,0x6E,
-	0x20,0x36,0x30,0x48,0x7A,0x20,0x28,0x6F,0x72,0x20,0x35,0x39,
+	0x6F,0x74,0x20,0x73,0x65,0x74,0x20,0x74,0x6F,0x20,0x36,0x30,
-	0x48,0x7A,0x29,0x4F,0x3E,0x40,0x58,0x30,0x32,0x31,0x79,0x6F,
+	0x48,0x7A,0x20,0x28,0x6F,0x72,0x20,0x35,0x39,0x48,0x7A,0x29,
-	0x75,0x20,0x6D,0x61,0x79,0x20,0x65,0x78,0x70,0x65,0x72,0x69,
+	0x4F,0x3E,0x40,0x58,0x30,0x32,0x31,0x79,0x6F,0x75,0x20,0x6D,
-	0x65,0x6E,0x63,0x65,0x20,0x76,0x69,0x73,0x75,0x61,0x6C,0x20,
+	0x61,0x79,0x20,0x65,0x78,0x70,0x65,0x72,0x69,0x65,0x6E,0x63,
-	0x73,0x74,0x75,0x74,0x74,0x65,0x72,0x69,0x6E,0x67,0x20,0x62,
+	0x65,0x20,0x76,0x69,0x73,0x75,0x61,0x6C,0x20,0x73,0x74,0x75,
-	0x65,0x63,0x61,0x75,0x73,0x65,0x20,0x56,0x53,0x79,0x6E,0x63,
+	0x74,0x74,0x65,0x72,0x69,0x6E,0x67,0x20,0x62,0x65,0x63,0x61,
-	0x20,0x77,0x69,0x6C,0x6C,0x20,0x6E,0x6F,0x74,0x20,0x62,0x65,
+	0x75,0x73,0x65,0x20,0x56,0x53,0x79,0x6E,0x63,0x20,0x77,0x69,
-	0x20,0x75,0x73,0x65,0x64,0x20,0x74,0x68,0x65,0x6E,0x2E,0x51,
+	0x6C,0x6C,0x20,0x6E,0x6F,0x74,0x20,0x62,0x65,0x20,0x75,0x73,
-	0x49,0x20,0x68,0x69,0x67,0x68,0x6C,0x79,0x20,0x72,0x65,0x63,
+	0x65,0x64,0x20,0x74,0x68,0x65,0x6E,0x2E,0x51,0x49,0x20,0x68,
-	0x6F,0x6D,0x6D,0x65,0x6E,0x64,0x20,0x72,0x75,0x6E,0x6E,0x69,
+	0x69,0x67,0x68,0x6C,0x79,0x20,0x72,0x65,0x63,0x6F,0x6D,0x6D,
-	0x6E,0x67,0x20,0x79,0x6F,0x75,0x72,0x20,0x6D,0x6F,0x6E,0x69,
+	0x65,0x6E,0x64,0x20,0x72,0x75,0x6E,0x6E,0x69,0x6E,0x67,0x20,
-	0x74,0x6F,0x72,0x20,0x61,0x74,0x20,0x36,0x30,0x48,0x7A,0x20,
+	0x79,0x6F,0x75,0x72,0x20,0x6D,0x6F,0x6E,0x69,0x74,0x6F,0x72,
-	0x69,0x66,0x20,0x79,0x6F,0x75,0x27,0x72,0x65,0x20,0x61,0x20,
+	0x20,0x61,0x74,0x20,0x36,0x30,0x48,0x7A,0x20,0x69,0x66,0x20,
-	0x68,0x61,0x72,0x64,0x63,0x6F,0x72,0x65,0x20,0x75,0x73,0x65,
+	0x79,0x6F,0x75,0x27,0x72,0x65,0x20,0x61,0x20,0x68,0x61,0x72,
-	0x72,0x20,0x6F,0x66,0x20,0x74,0x68,0x69,0x73,0x08,0x70,0x72,
+	0x64,0x63,0x6F,0x72,0x65,0x20,0x75,0x73,0x65,0x72,0x20,0x6F,
-	0x6F,0x67,0x72,0x61,0x6D,0x2E,0x00,0x03,0x45,0x4E,0x44
+	0x66,0x20,0x74,0x68,0x69,0x73,0x08,0x70,0x72,0x6F,0x67,0x72,
+	0x61,0x6D,0x2E,0x00,0x03,0x45,0x4E,0x44
 };
 #endif

src/mixer/ft2_mix_macros.h+2−11

@@ -253,18 +253,9 @@ · 252 unmodified lines
253		253
254	#define LIMIT_MIX_NUM \	254	#define LIMIT_MIX_NUM \
255	i = (v->end - 1) - pos; \	255	i = (v->end - 1) - pos; \
256	if (i > 65535) \	256	const uint64_t tmp64 = ((uint64_t)i << 32) \| ((uint32_t)posFrac ^ 0xFFFFFFFF); \
257	i = 65535; \
258	\
259	i = (i << 16) \| ((uint32_t)(posFrac >> 16) ^ 0xFFFF); \
260	\
261	/* This is hackish, but fast. This is sometimes off by one (-1), so */ \
262	/* we need to do another cycle to reach the end of the sample. The */ \
263	/* error is never +1, it's always below (safe). */ \
264	\
265	samplesToMix = ((int64_t)i * v->revDelta) >> 32; \
266	samplesToMix++; \
267	\	257	\
		258	samplesToMix = (uint32_t)(tmp64 / (uint64_t)v->delta) + 1; /* this can be slow on 32-bit systems... */ \
268	if (samplesToMix > samplesLeft) \	259	if (samplesToMix > samplesLeft) \
269	samplesToMix = samplesLeft; \	260	samplesToMix = samplesLeft; \
270		261

src/modloaders/ft2_load_digi.c+260−0

@@ -0,0 +1,260 @@
	1	// DIGI Booster (non-Pro) module loader
	2
	3	#include <stdio.h>
	4	#include <stdint.h>
	5	#include <stdbool.h>
	6	#include "../ft2_header.h"
	7	#include "../ft2_module_loader.h"
	8	#include "../ft2_sample_ed.h"
	9	#include "../ft2_tables.h"
	10	#include "../ft2_sysreqs.h"
	11
	12	#ifdef _MSC_VER // please don't mess with this struct!
	13	#pragma pack(push)
	14	#pragma pack(1)
	15	#endif
	16	typedef struct digiHeaderTyp_t
	17	{
	18	char sig[20];
	19	char verStr[4];
	20	uint8_t ver;
	21	uint8_t numChannels;
	22	uint8_t packedPatternsFlag;
	23	char reserved[19];
	24	uint8_t numPats;
	25	uint8_t numOrders;
	26	uint8_t orders[128];
	27	uint32_t smpLength[31];
	28	uint32_t smpLoopStart[31];
	29	uint32_t smpLoopLength[31];
	30	uint8_t smpVolume[31];
	31	uint8_t smpFinetune[31];
	32	char name[32];
	33	char smpName[31][30];
	34	}
	35	#ifdef __GNUC__
	36	__attribute__ ((packed))
	37	#endif
	38	digiHeaderTyp;
	39	#ifdef _MSC_VER
	40	#pragma pack(pop)
	41	#endif
	42
	43	static void readPatternNote(FILE f, tonTyp ton);
	44
	45	bool loadDIGI(FILE *f, uint32_t filesize)
	46	{
	47	int16_t i, j, k;
	48	tonTyp *ton;
	49	sampleTyp *s;
	50	digiHeaderTyp h_DIGI;
	51
	52	tmpLinearPeriodsFlag = false; // use Amiga periods
	53
	54	if (filesize < sizeof (h_DIGI))
	55	{
	56	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	57	return false;
	58	}
	59
	60	memset(&h_DIGI, 0, sizeof (digiHeaderTyp));
	61	if (fread(&h_DIGI, 1, sizeof (h_DIGI), f) != sizeof (h_DIGI))
	62	{
	63	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	64	return false;
	65	}
	66
	67	if (h_DIGI.numChannels < 1 \|\| h_DIGI.numChannels > 8)
	68	{
	69	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	70	return false;
	71	}
	72
	73	h_DIGI.numOrders++;
	74	h_DIGI.numPats++;
	75
	76	if (h_DIGI.numOrders < 1 \|\| h_DIGI.numOrders > 128)
	77	{
	78	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	79	return false;
	80	}
	81
	82	songTmp.antChn = h_DIGI.numChannels;
	83	songTmp.len = h_DIGI.numOrders;
	84	songTmp.initialTempo = songTmp.tempo = 6;
	85	songTmp.speed = 125;
	86	memcpy(songTmp.songTab, h_DIGI.orders, 128);
	87
	88	// load pattern data
	89	for (i = 0; i < h_DIGI.numPats; i++)
	90	{
	91	if (!allocateTmpPatt(i, 64))
	92	{
	93	loaderMsgBox("Not enough memory!");
	94	return false;
	95	}
	96
	97	if (h_DIGI.packedPatternsFlag)
	98	{
	99	uint16_t pattSize;
	100	uint8_t bitMasks[64];
	101
	102	fread(&pattSize, 2, 1, f); pattSize = SWAP16(pattSize);
	103	fread(bitMasks, 1, 64, f);
	104
	105	for (j = 0; j < 64; j++)
	106	{
	107	uint8_t bit = 128;
	108	for (k = 0; k < songTmp.antChn; k++, bit >>= 1)
	109	{
	110	ton = &pattTmp[i][(j * MAX_VOICES) + k];
	111	if (bitMasks[j] & bit)
	112	readPatternNote(f, ton);
	113	}
	114	}
	115	}
	116	else
	117	{
	118	for (j = 0; j < songTmp.antChn; j++)
	119	{
	120	for (k = 0; k < 64; k++)
	121	{
	122	ton = &pattTmp[i][(k * MAX_VOICES) + j];
	123	readPatternNote(f, ton);
	124	}
	125	}
	126	}
	127
	128	if (tmpPatternEmpty(i))
	129	{
	130	if (pattTmp[i] != NULL)
	131	{
	132	free(pattTmp[i]);
	133	pattTmp[i] = NULL;
	134	}
	135	}
	136	}
	137
	138	// pattern command handling
	139	for (i = 0; i < h_DIGI.numPats; i++)
	140	{
	141	if (pattTmp[i] == NULL)
	142	continue;
	143
	144	for (j = 0; j < 64; j++)
	145	{
	146	for (k = 0; k < songTmp.antChn; k++)
	147	{
	148	ton = &pattTmp[i][(j * MAX_VOICES) + k];
	149
	150	if (ton->effTyp == 0x8) // Robot effect (not supported)
	151	{
	152	ton->effTyp = 0;
	153	ton->eff = 0;
	154	}
	155	else if (ton->effTyp == 0xE)
	156	{
	157	switch (ton->eff >> 4)
	158	{
	159	case 0x3: ton->effTyp = ton->eff = 0; break; // backwards play (not supported)
	160	case 0x4: ton->eff = 0xC0; break; // stop sample (convert to EC0)
	161	case 0x8: ton->effTyp = ton->eff = 0; break; // high sample offset (not supported)
	162	case 0x9: ton->effTyp = ton->eff = 0; break; // retrace (not supported)
	163	default: break;
	164	}
	165	}
	166	}
	167	}
	168	}
	169
	170	// load sample data
	171	for (i = 0; i < 31; i++)
	172	{
	173	memcpy(songTmp.instrName[1+i], h_DIGI.smpName[i], 22);
	174	if (h_DIGI.smpLength[i] == 0)
	175	continue;
	176
	177	if (!allocateTmpInstr(1+i))
	178	{
	179	loaderMsgBox("Not enough memory!");
	180	return false;
	181	}
	182
	183	setNoEnvelope(instrTmp[1+i]);
	184
	185	s = &instrTmp[1+i]->samp[0];
	186	memcpy(s->name, h_DIGI.smpName[i], 22);
	187
	188	s->len = SWAP32(h_DIGI.smpLength[i]);
	189	s->fine = 8 * ((2 * ((h_DIGI.smpFinetune[i] & 0xF) ^ 8)) - 16);
	190	s->vol = h_DIGI.smpVolume[i];
	191	s->repS = SWAP32(h_DIGI.smpLoopStart[i]);
	192	s->repL = SWAP32(h_DIGI.smpLoopLength[i]);
	193
	194	if (s->vol > 64)
	195	s->vol = 64;
	196
	197	if (s->repL < 2)
	198	s->repL = 2;
	199
	200	// fix overflown loop
	201	if (s->repS+s->repL > s->len)
	202	{
	203	if (s->repS >= s->len)
	204	{
	205	s->repS = 0;
	206	s->repL = 0;
	207	}
	208	else
	209	{
	210	s->repL = s->len - s->repS;
	211	}
	212	}
	213
	214	if (s->repS+s->repL > 2)
	215	{
	216	s->typ = 1; // enable loop
	217	}
	218	else
	219	{
	220	s->repS = 0;
	221	s->repL = 0;
	222	}
	223
	224	if (!allocateTmpSmpData(s, s->len))
	225	{
	226	loaderMsgBox("Not enough memory!");
	227	return false;
	228	}
	229
	230	int32_t bytesRead = (int32_t)fread(s->pek, 1, s->len, f);
	231	if (bytesRead < s->len)
	232	{
	233	int32_t bytesToClear = s->len - bytesRead;
	234	memset(&s->pek[bytesRead], 0, bytesToClear);
	235	}
	236	}
	237
	238	return true;
	239	}
	240
	241	static void readPatternNote(FILE f, tonTyp ton)
	242	{
	243	uint8_t bytes[4];
	244	fread(bytes, 1, 4, f);
	245
	246	// period to note
	247	uint16_t period = ((bytes[0] & 0x0F) << 8) \| bytes[1];
	248	for (uint8_t i = 0; i < 3*12; i++)
	249	{
	250	if (period >= ptPeriods[i])
	251	{
	252	ton->ton = 1 + (3*12) + i;
	253	break;
	254	}
	255	}
	256
	257	ton->instr = (bytes[0] & 0xF0) \| (bytes[2] >> 4);
	258	ton->effTyp = bytes[2] & 0x0F;
	259	ton->eff = bytes[3];
	260	}

src/modloaders/ft2_load_mod.c+408−0

@@ -0,0 +1,408 @@
	1	// NoiseTracker/ProTracker (or compatible) MOD loader
	2
	3	#include <stdio.h>
	4	#include <stdint.h>
	5	#include <stdbool.h>
	6	#include "../ft2_header.h"
	7	#include "../ft2_module_loader.h"
	8	#include "../ft2_sample_ed.h"
	9	#include "../ft2_tables.h"
	10	#include "../ft2_sysreqs.h"
	11
	12	enum // supported 31-sample .MOD types
	13	{
	14	FORMAT_MK, // ProTracker or compatible
	15	FORMAT_FLT4, // StarTrekker (4ch modules)
	16	FORMAT_FLT8, // StarTrekker (8ch modules)
	17	FORMAT_FT2, // FT2 or compatible (multi-channel)
	18	FORMAT_NT, // NoiseTracker
	19	FORMAT_HMNT, // His Master's NoiseTracker (special one)
	20
	21	FORMAT_UNKNOWN
	22	};
	23
	24	static uint8_t getModType(uint8_t numChannels, const char id);
	25
	26	bool loadMOD(FILE *f, uint32_t filesize)
	27	{
	28	uint8_t bytes[4], modFormat, numChannels;
	29	int16_t i, j, k;
	30	uint16_t a, b, period;
	31	tonTyp *ton;
	32	sampleTyp *s;
	33	songMOD31HeaderTyp h_MOD31;
	34
	35	tmpLinearPeriodsFlag = false; // use Amiga periods
	36
	37	if (filesize < sizeof (h_MOD31))
	38	{
	39	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	40	return false;
	41	}
	42
	43	memset(&h_MOD31, 0, sizeof (songMOD31HeaderTyp));
	44	if (fread(&h_MOD31, 1, sizeof (h_MOD31), f) != sizeof (h_MOD31))
	45	{
	46	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	47	return false;
	48	}
	49
	50	modFormat = getModType(&numChannels, h_MOD31.sig);
	51	if (modFormat == FORMAT_UNKNOWN)
	52	{
	53	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	54	return false;
	55	}
	56
	57	songTmp.antChn = numChannels;
	58	songTmp.len = h_MOD31.len;
	59	songTmp.repS = h_MOD31.repS;
	60	songTmp.initialTempo = songTmp.tempo = 6;
	61	songTmp.speed = 125;
	62
	63	memcpy(songTmp.songTab, h_MOD31.songTab, 128);
	64
	65	if (modFormat == FORMAT_MK && songTmp.len == 129)
	66	songTmp.len = 127; // fixes a specific copy of beatwave.mod (FIXME: Do we want to keep this hack?)
	67
	68	if (songTmp.repS >= songTmp.len)
	69	songTmp.repS = 0;
	70
	71	if (songTmp.antChn == 0 \|\| songTmp.len < 1 \|\| songTmp.len > 128)
	72	{
	73	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	74	return false;
	75	}
	76
	77	for (a = 0; a < 31; a++)
	78	{
	79	songMODInstrHeaderTyp *smp = &h_MOD31.instr[a];
	80
	81	// copy over sample name if format isn't "His Master's Noisetracker" (junk sample names)
	82	if (modFormat != FORMAT_HMNT)
	83	memcpy(songTmp.instrName[1+a], smp->name, 22);
	84	}
	85
	86	memcpy(songTmp.name, h_MOD31.name, 20);
	87
	88	// count number of patterns
	89	b = 0;
	90	for (a = 0; a < 128; a++)
	91	{
	92	if (modFormat == FORMAT_FLT8)
	93	songTmp.songTab[a] >>= 1;
	94
	95	if (songTmp.songTab[a] > b)
	96	b = songTmp.songTab[a];
	97	}
	98	b++;
	99
	100	// load pattern data
	101	if (modFormat != FORMAT_FLT8)
	102	{
	103	// normal pattern loading
	104
	105	for (a = 0; a < b; a++)
	106	{
	107	if (!allocateTmpPatt(a, 64))
	108	{
	109	loaderMsgBox("Not enough memory!");
	110	return false;
	111	}
	112
	113	for (j = 0; j < 64; j++)
	114	{
	115	for (k = 0; k < songTmp.antChn; k++)
	116	{
	117	ton = &pattTmp[a][(j * MAX_VOICES) + k];
	118	fread(bytes, 1, 4, f);
	119
	120	// period to note
	121	period = ((bytes[0] & 0x0F) << 8) \| bytes[1];
	122	for (i = 0; i < 8*12; i++)
	123	{
	124	if (period >= amigaPeriod[i])
	125	{
	126	ton->ton = (uint8_t)i + 1;
	127	break;
	128	}
	129	}
	130
	131	ton->instr = (bytes[0] & 0xF0) \| (bytes[2] >> 4);
	132	ton->effTyp = bytes[2] & 0x0F;
	133	ton->eff = bytes[3];
	134	}
	135	}
	136
	137	if (tmpPatternEmpty(a))
	138	{
	139	if (pattTmp[a] != NULL)
	140	{
	141	free(pattTmp[a]);
	142	pattTmp[a] = NULL;
	143	}
	144	}
	145	}
	146	}
	147	else
	148	{
	149	// FLT8 pattern loading
	150
	151	for (a = 0; a < b; a++)
	152	{
	153	if (!allocateTmpPatt(a, 64))
	154	{
	155	loaderMsgBox("Not enough memory!");
	156	return false;
	157	}
	158	}
	159
	160	for (a = 0; a < b*2; a++)
	161	{
	162	int32_t pattern = a >> 1;
	163	int32_t chnOffset = (a & 1) * 4;
	164
	165	for (j = 0; j < 64; j++)
	166	{
	167	for (k = 0; k < 4; k++)
	168	{
	169	ton = &pattTmp[pattern][(j * MAX_VOICES) + (k+chnOffset)];
	170	fread(bytes, 1, 4, f);
	171
	172	// period to note
	173	period = ((bytes[0] & 0x0F) << 8) \| bytes[1];
	174	for (i = 0; i < 8*12; i++)
	175	{
	176	if (period >= amigaPeriod[i])
	177	{
	178	ton->ton = (uint8_t)i + 1;
	179	break;
	180	}
	181	}
	182
	183	ton->instr = (bytes[0] & 0xF0) \| (bytes[2] >> 4);
	184	ton->effTyp = bytes[2] & 0x0F;
	185	ton->eff = bytes[3];
	186	}
	187	}
	188	}
	189
	190	for (a = 0; a < b; a++)
	191	{
	192	if (tmpPatternEmpty(a))
	193	{
	194	if (pattTmp[a] != NULL)
	195	{
	196	free(pattTmp[a]);
	197	pattTmp[a] = NULL;
	198	}
	199	}
	200	}
	201	}
	202
	203	// pattern command conversion
	204	for (a = 0; a < b; a++)
	205	{
	206	if (pattTmp[a] == NULL)
	207	continue;
	208
	209	for (j = 0; j < 64; j++)
	210	{
	211	for (k = 0; k < songTmp.antChn; k++)
	212	{
	213	ton = &pattTmp[a][(j * MAX_VOICES) + k];
	214
	215	if (ton->effTyp == 0xC)
	216	{
	217	if (ton->eff > 64)
	218	ton->eff = 64;
	219	}
	220	else if (ton->effTyp == 0x1)
	221	{
	222	if (ton->eff == 0)
	223	ton->effTyp = 0;
	224	}
	225	else if (ton->effTyp == 0x2)
	226	{
	227	if (ton->eff == 0)
	228	ton->effTyp = 0;
	229	}
	230	else if (ton->effTyp == 0x5)
	231	{
	232	if (ton->eff == 0)
	233	ton->effTyp = 0x3;
	234	}
	235	else if (ton->effTyp == 0x6)
	236	{
	237	if (ton->eff == 0)
	238	ton->effTyp = 0x4;
	239	}
	240	else if (ton->effTyp == 0xA)
	241	{
	242	if (ton->eff == 0)
	243	ton->effTyp = 0;
	244	}
	245	else if (ton->effTyp == 0xE)
	246	{
	247	// check if certain E commands are empty
	248	if (ton->eff == 0x10 \|\| ton->eff == 0x20 \|\| ton->eff == 0xA0 \|\| ton->eff == 0xB0)
	249	{
	250	ton->effTyp = 0;
	251	ton->eff = 0;
	252	}
	253	}
	254
	255	if (modFormat == FORMAT_NT \|\| modFormat == FORMAT_HMNT)
	256	{
	257	// any Dxx == D00 in NT/HMNT
	258	if (ton->effTyp == 0xD)
	259	ton->eff = 0;
	260
	261	// effect F with param 0x00 does nothing in NT/HMNT
	262	if (ton->effTyp == 0xF && ton->eff == 0)
	263	ton->effTyp = 0;
	264	}
	265	else if (modFormat == FORMAT_FLT4 \|\| modFormat == FORMAT_FLT8) // Startrekker
	266	{
	267	if (ton->effTyp == 0xE) // remove unsupported "assembly macros" command
	268	{
	269	ton->effTyp = 0;
	270	ton->eff = 0;
	271	}
	272
	273	// Startrekker is always in vblank mode, and limits speed to 0x1F
	274	if (ton->effTyp == 0xF && ton->eff > 0x1F)
	275	ton->eff = 0x1F;
	276	}
	277	}
	278	}
	279	}
	280
	281	for (a = 0; a < 31; a++)
	282	{
	283	if (h_MOD31.instr[a].len == 0)
	284	continue;
	285
	286	if (!allocateTmpInstr(1+a))
	287	{
	288	loaderMsgBox("Not enough memory!");
	289	return false;
	290	}
	291
	292	setNoEnvelope(instrTmp[1+a]);
	293
	294	s = &instrTmp[1+a]->samp[0];
	295
	296	// copy over sample name if format isn't "His Master's Noisetracker" (junk sample names)
	297	if (modFormat != FORMAT_HMNT)
	298	memcpy(s->name, songTmp.instrName[1+a], 22);
	299
	300	if (modFormat == FORMAT_HMNT) // finetune in "His Master's NoiseTracker" is different
	301	h_MOD31.instr[a].fine = (uint8_t)((-h_MOD31.instr[a].fine & 0x1F) >> 1); // one more bit of precision, + inverted
	302
	303	s->len = 2 * SWAP16(h_MOD31.instr[a].len);
	304	s->fine = 8 * ((2 * ((h_MOD31.instr[a].fine & 0xF) ^ 8)) - 16);
	305	s->vol = h_MOD31.instr[a].vol;
	306	s->repS = 2 * SWAP16(h_MOD31.instr[a].repS);
	307	s->repL = 2 * SWAP16(h_MOD31.instr[a].repL);
	308
	309	if (s->vol > 64)
	310	s->vol = 64;
	311
	312	if (s->repL < 2)
	313	s->repL = 2;
	314
	315	// fix for poorly converted STK (< v2.5) -> PT/NT modules (FIXME: Worth keeping or not?)
	316	if (s->repL > 2 && s->repS+s->repL > s->len)
	317	{
	318	if ((s->repS>>1)+s->repL <= s->len)
	319	s->repS >>= 1;
	320	}
	321
	322	// fix overflown loop
	323	if (s->repS+s->repL > s->len)
	324	{
	325	if (s->repS >= s->len)
	326	{
	327	s->repS = 0;
	328	s->repL = 0;
	329	}
	330	else
	331	{
	332	s->repL = s->len - s->repS;
	333	}
	334	}
	335
	336	if (s->repS+s->repL > 2)
	337	s->typ = 1; // enable loop
	338
	339	if (!allocateTmpSmpData(s, s->len))
	340	{
	341	loaderMsgBox("Not enough memory!");
	342	return false;
	343	}
	344
	345	int32_t bytesRead = (int32_t)fread(s->pek, 1, s->len, f);
	346	if (bytesRead < s->len)
	347	{
	348	int32_t bytesToClear = s->len - bytesRead;
	349	memset(&s->pek[bytesRead], 0, bytesToClear);
	350	}
	351
	352	if (s->typ == 0) // clear repL and repS on non-looping samples...
	353	{
	354	s->repL = 0;
	355	s->repS = 0;
	356	}
	357	}
	358
	359	return true;
	360	}
	361
	362	static uint8_t getModType(uint8_t numChannels, const char id)
	363	{
	364	#define IS_ID(s, b) !strncmp(s, b, 4)
	365
	366	uint8_t modFormat = FORMAT_UNKNOWN;
	367	*numChannels = 4;
	368
	369	if (IS_ID("M.K.", id) \|\| IS_ID("M!K!", id) \|\| IS_ID("NSMS", id) \|\|
	370	IS_ID("LARD", id) \|\| IS_ID("PATT", id))
	371	{
	372	modFormat = FORMAT_MK; // ProTracker or compatible
	373	}
	374	else if (isdigit(id[0]) && id[1] == 'C' && id[2] == 'H' && id[3] == 'N') // xCHN
	375	{
	376	modFormat = FORMAT_FT2; // FT2 or compatible (multi-channel)
	377	*numChannels = id[0] - '0';
	378	}
	379	else if (isdigit(id[0]) && isdigit(id[1]) && id[2] == 'C' && id[3] == 'H') // xxCH
	380	{
	381	modFormat = FORMAT_FT2; // FT2 or compatible (multi-channel)
	382	numChannels = ((id[0] - '0') 10) + (id[1] - '0');
	383	}
	384	else if (isdigit(id[0]) && isdigit(id[1]) && id[2] == 'C' && id[3] == 'N') // xxCN (load as xxCH)
	385	{
	386	modFormat = FORMAT_FT2; // FT2 or compatible (multi-channel)
	387	numChannels = ((id[0] - '0') 10) + (id[1] - '0');
	388	}
	389	else if (IS_ID("FLT4", id))
	390	{
	391	modFormat = FORMAT_FLT4; // StarTrekker (4ch modules)
	392	}
	393	else if (IS_ID("FLT8", id))
	394	{
	395	modFormat = FORMAT_FLT8; // StarTrekker (8ch modules)
	396	*numChannels = 8;
	397	}
	398	else if (IS_ID("N.T.", id))
	399	{
	400	modFormat = FORMAT_NT; // NoiseTracker
	401	}
	402	else if (IS_ID("M&K!", id) \|\| IS_ID("FEST", id))
	403	{
	404	modFormat = FORMAT_HMNT; // His Master's NoiseTracker (special one)
	405	}
	406
	407	return modFormat;
	408	}

src/modloaders/ft2_load_s3m.c+663−0

@@ -0,0 +1,663 @@
	1	// Scream Tracker 3 (or compatible) S3M loader
	2
	3	#include <stdio.h>
	4	#include <stdint.h>
	5	#include <stdbool.h>
	6	#include "../ft2_header.h"
	7	#include "../ft2_module_loader.h"
	8	#include "../ft2_sample_ed.h"
	9	#include "../ft2_tables.h"
	10	#include "../ft2_sysreqs.h"
	11
	12	#ifdef _MSC_VER // please don't mess with these structs!
	13	#pragma pack(push)
	14	#pragma pack(1)
	15	#endif
	16	typedef struct songS3MinstrHeaderTyp_t
	17	{
	18	uint8_t typ;
	19	char dosName[12];
	20	uint8_t memSegH;
	21	uint16_t memSeg;
	22	int32_t len, repS, repE;
	23	uint8_t vol, dsk, pack, flags;
	24	int32_t c2Spd, res1;
	25	uint16_t gusPos;
	26	uint8_t res2[6];
	27	char name[28], id[4];
	28	}
	29	#ifdef __GNUC__
	30	__attribute__ ((packed))
	31	#endif
	32	songS3MinstrHeaderTyp;
	33
	34	typedef struct songS3MHeaderTyp_t
	35	{
	36	char name[28];
	37	uint8_t id1a, typ;
	38	uint16_t res1;
	39	int16_t songTabLen, antInstr, antPatt;
	40	uint16_t flags, trackerID, ver;
	41	char id[4];
	42	uint8_t globalVol, defSpeed, defTempo, masterVol, res2[12], chanType[32];
	43	}
	44	#ifdef __GNUC__
	45	__attribute__ ((packed))
	46	#endif
	47	songS3MHeaderTyp;
	48	#ifdef _MSC_VER
	49	#pragma pack(pop)
	50	#endif
	51
	52	static uint8_t pattBuff[12288];
	53
	54	static int8_t countS3MChannels(uint16_t antPtn);
	55
	56	bool loadS3M(FILE *f, uint32_t filesize)
	57	{
	58	uint8_t ha[2048];
	59	uint8_t alastnfo[32], alastefx[32], alastvibnfo[32], s3mLastGInstr[32];
	60	uint8_t typ;
	61	int16_t ai, ap, ver, ii, kk, tmp;
	62	uint16_t ptnOfs[256];
	63	int32_t i, j, k, len;
	64	tonTyp ton;
	65	sampleTyp *s;
	66	songS3MHeaderTyp h_S3M;
	67	songS3MinstrHeaderTyp h_S3MInstr;
	68
	69	tmpLinearPeriodsFlag = false; // use Amiga periods
	70
	71	if (filesize < sizeof (h_S3M))
	72	{
	73	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	74	return false;
	75	}
	76
	77	memset(&h_S3M, 0, sizeof (h_S3M));
	78	if (fread(&h_S3M, 1, sizeof (h_S3M), f) != sizeof (h_S3M))
	79	{
	80	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	81	return false;
	82	}
	83
	84	if (h_S3M.antInstr > MAX_INST \|\| h_S3M.songTabLen > 256 \|\| h_S3M.antPatt > 256 \|\|
	85	h_S3M.typ != 16 \|\| h_S3M.ver < 1 \|\| h_S3M.ver > 2)
	86	{
	87	loaderMsgBox("Error loading .s3m: Incompatible module!");
	88	return false;
	89	}
	90
	91	memset(songTmp.songTab, 255, sizeof (songTmp.songTab));
	92	if (fread(songTmp.songTab, h_S3M.songTabLen, 1, f) != 1)
	93	{
	94	loaderMsgBox("General I/O error during loading! Is the file in use?");
	95	return false;
	96	}
	97
	98	songTmp.len = h_S3M.songTabLen;
	99
	100	// remove pattern separators (254)
	101	k = 0;
	102	j = 0;
	103	for (i = 0; i < songTmp.len; i++)
	104	{
	105	if (songTmp.songTab[i] != 254)
	106	songTmp.songTab[j++] = songTmp.songTab[i];
	107	else
	108	k++;
	109	}
	110
	111	if (k <= songTmp.len)
	112	songTmp.len -= (uint16_t)k;
	113	else
	114	songTmp.len = 1;
	115
	116	for (i = 1; i < songTmp.len; i++)
	117	{
	118	if (songTmp.songTab[i] == 255)
	119	{
	120	songTmp.len = (uint16_t)i;
	121	break;
	122	}
	123	}
	124
	125	// clear unused song table entries
	126	if (songTmp.len < 255)
	127	memset(&songTmp.songTab[songTmp.len], 0, 255-songTmp.len);
	128
	129	songTmp.speed = h_S3M.defTempo;
	130	if (songTmp.speed < 32)
	131	songTmp.speed = 32;
	132
	133	songTmp.tempo = h_S3M.defSpeed;
	134	if (songTmp.tempo == 0)
	135	songTmp.tempo = 6;
	136
	137	if (songTmp.tempo > 31)
	138	songTmp.tempo = 31;
	139
	140	songTmp.initialTempo = songTmp.tempo;
	141	memcpy(songTmp.name, h_S3M.name, 20);
	142
	143	ap = h_S3M.antPatt;
	144	ai = h_S3M.antInstr;
	145	ver = h_S3M.ver;
	146
	147	k = 31;
	148	while (k >= 0 && h_S3M.chanType[k] >= 16) k--;
	149	songTmp.antChn = (k + 2) & 254;
	150
	151	if (fread(ha, ai*2, 1, f) != 1)
	152	{
	153	loaderMsgBox("General I/O error during loading! Is the file in use?");
	154	return false;
	155	}
	156
	157	if (fread(ptnOfs, ap*2, 1, f) != 1)
	158	{
	159	loaderMsgBox("General I/O error during loading! Is the file in use?");
	160	return false;
	161	}
	162
	163	// * PATTERNS *
	164
	165	k = 0;
	166	for (i = 0; i < ap; i++)
	167	{
	168	if (ptnOfs[i] == 0)
	169	continue; // empty pattern
	170
	171	memset(alastnfo, 0, sizeof (alastnfo));
	172	memset(alastefx, 0, sizeof (alastefx));
	173	memset(alastvibnfo, 0, sizeof (alastvibnfo));
	174	memset(s3mLastGInstr, 0, sizeof (s3mLastGInstr));
	175
	176	fseek(f, ptnOfs[i] << 4, SEEK_SET);
	177	if (feof(f))
	178	continue;
	179
	180	if (fread(&j, 2, 1, f) != 1)
	181	{
	182	loaderMsgBox("General I/O error during loading! Is the file in use?");
	183	return false;
	184	}
	185
	186	if (j > 0 && j <= 12288)
	187	{
	188	if (!allocateTmpPatt(i, 64))
	189	{
	190	loaderMsgBox("Not enough memory!");
	191	return false;
	192	}
	193
	194	fread(pattBuff, j, 1, f);
	195
	196	k = 0;
	197	kk = 0;
	198
	199	while (k < j && kk < 64)
	200	{
	201	typ = pattBuff[k++];
	202
	203	if (typ == 0)
	204	{
	205	kk++;
	206	}
	207	else
	208	{
	209	ii = typ & 31;
	210
	211	memset(&ton, 0, sizeof (ton));
	212
	213	// note and sample
	214	if (typ & 32)
	215	{
	216	ton.ton = pattBuff[k++];
	217	ton.instr = pattBuff[k++];
	218
	219	if (ton.instr > MAX_INST)
	220	ton.instr = 0;
	221
	222	if (ton.ton == 254) ton.ton = 97;
	223	else if (ton.ton == 255) ton.ton = 0;
	224	else
	225	{
	226	ton.ton = 1 + (ton.ton & 0xF) + (ton.ton >> 4) * 12;
	227	if (ton.ton > 96)
	228	ton.ton = 0;
	229	}
	230	}
	231
	232	// volume column
	233	if (typ & 64)
	234	{
	235	ton.vol = pattBuff[k++];
	236
	237	if (ton.vol <= 64)
	238	ton.vol += 0x10;
	239	else
	240	ton.vol = 0;
	241	}
	242
	243	// effect
	244	if (typ & 128)
	245	{
	246	ton.effTyp = pattBuff[k++];
	247	ton.eff = pattBuff[k++];
	248
	249	if (ton.eff > 0)
	250	{
	251	alastnfo[ii] = ton.eff;
	252	if (ton.effTyp == 8 \|\| ton.effTyp == 21)
	253	alastvibnfo[ii] = ton.eff; // H/U
	254	}
	255
	256	// in ST3, a lot of effects directly share the same memory!
	257	if (ton.eff == 0 && ton.effTyp != 7) // G
	258	{
	259	uint8_t efx = ton.effTyp;
	260	if (efx == 8 \|\| efx == 21) // H/U
	261	ton.eff = alastvibnfo[ii];
	262	else if ((efx >= 4 && efx <= 12) \|\| (efx >= 17 && efx <= 19)) // D/E/F/I/J/K/L/Q/R/S
	263	ton.eff = alastnfo[ii];
	264
	265	/* If effect data is zero and effect type was the same as last one, clear out
	266	** data if it's not J or S (those have no memory in the equivalent XM effects).
	267	** Also goes for extra fine pitch slides and fine volume slides,
	268	** since they get converted to other effects.
	269	*/
	270	if (efx == alastefx[ii] && ton.effTyp != 10 && ton.effTyp != 19) // J/S
	271	{
	272	uint8_t nfo = ton.eff;
	273	bool extraFinePitchSlides = (efx == 5 \|\| efx == 6) && ((nfo & 0xF0) == 0xE0);
	274	bool fineVolSlides = (efx == 4 \|\| efx == 11) &&
	275	((nfo > 0xF0) \|\| (((nfo & 0xF) == 0xF) && ((nfo & 0xF0) > 0)));
	276
	277	if (!extraFinePitchSlides && !fineVolSlides)
	278	ton.eff = 0;
	279	}
	280	}
	281
	282	if (ton.effTyp > 0)
	283	alastefx[ii] = ton.effTyp;
	284
	285	switch (ton.effTyp)
	286	{
	287	case 1: // A
	288	{
	289	ton.effTyp = 0xF;
	290	if (ton.eff == 0 \|\| ton.eff > 0x1F)
	291	{
	292	ton.effTyp = 0;
	293	ton.eff = 0;
	294	}
	295	}
	296	break;
	297
	298	case 2: ton.effTyp = 0xB; break; // B
	299	case 3: ton.effTyp = 0xD; break; // C
	300	case 4: // D
	301	{
	302	if (ton.eff > 0xF0) // fine slide up
	303	{
	304	ton.effTyp = 0xE;
	305	ton.eff = 0xB0 \| (ton.eff & 0xF);
	306	}
	307	else if ((ton.eff & 0x0F) == 0x0F && (ton.eff & 0xF0) > 0) // fine slide down
	308	{
	309	ton.effTyp = 0xE;
	310	ton.eff = 0xA0 \| (ton.eff >> 4);
	311	}
	312	else
	313	{
	314	ton.effTyp = 0xA;
	315	if (ton.eff & 0x0F) // on D/K, last nybble has first priority in ST3
	316	ton.eff &= 0x0F;
	317	}
	318	}
	319	break;
	320
	321	case 5: // E
	322	case 6: // F
	323	{
	324	if ((ton.eff & 0xF0) >= 0xE0)
	325	{
	326	// convert to fine slide
	327	if ((ton.eff & 0xF0) == 0xE0)
	328	tmp = 0x21;
	329	else
	330	tmp = 0xE;
	331
	332	ton.eff &= 0x0F;
	333
	334	if (ton.effTyp == 0x05)
	335	ton.eff \|= 0x20;
	336	else
	337	ton.eff \|= 0x10;
	338
	339	ton.effTyp = (uint8_t)tmp;
	340
	341	if (ton.effTyp == 0x21 && ton.eff == 0)
	342	{
	343	ton.effTyp = 0;
	344	}
	345	}
	346	else
	347	{
	348	// convert to normal 1xx/2xx slide
	349	ton.effTyp = 7 - ton.effTyp;
	350	}
	351	}
	352	break;
	353
	354	case 7: // G
	355	{
	356	ton.effTyp = 0x03;
	357
	358	// fix illegal slides (to new instruments)
	359	if (ton.instr != 0 && ton.instr != s3mLastGInstr[ii])
	360	ton.instr = s3mLastGInstr[ii];
	361	}
	362	break;
	363
	364	case 11: // K
	365	{
	366	if (ton.eff > 0xF0) // fine slide up
	367	{
	368	ton.effTyp = 0xE;
	369	ton.eff = 0xB0 \| (ton.eff & 0xF);
	370
	371	// if volume column is unoccupied, set to vibrato
	372	if (ton.vol == 0)
	373	ton.vol = 0xB0;
	374	}
	375	else if ((ton.eff & 0x0F) == 0x0F && (ton.eff & 0xF0) > 0) // fine slide down
	376	{
	377	ton.effTyp = 0xE;
	378	ton.eff = 0xA0 \| (ton.eff >> 4);
	379
	380	// if volume column is unoccupied, set to vibrato
	381	if (ton.vol == 0)
	382	ton.vol = 0xB0;
	383	}
	384	else
	385	{
	386	ton.effTyp = 0x6;
	387	if (ton.eff & 0x0F) // on D/K, last nybble has first priority in ST3
	388	ton.eff &= 0x0F;
	389	}
	390	}
	391	break;
	392
	393	case 8: ton.effTyp = 0x04; break; // H
	394	case 9: ton.effTyp = 0x1D; break; // I
	395	case 10: ton.effTyp = 0x00; break; // J
	396	case 12: ton.effTyp = 0x05; break; // L
	397	case 15: ton.effTyp = 0x09; break; // O
	398	case 17: ton.effTyp = 0x1B; break; // Q
	399	case 18: ton.effTyp = 0x07; break; // R
	400
	401	case 19: // S
	402	{
	403	ton.effTyp = 0xE;
	404	tmp = ton.eff >> 4;
	405	ton.eff &= 0x0F;
	406
	407	if (tmp == 0x1) ton.eff \|= 0x30;
	408	else if (tmp == 0x2) ton.eff \|= 0x50;
	409	else if (tmp == 0x3) ton.eff \|= 0x40;
	410	else if (tmp == 0x4) ton.eff \|= 0x70;
	411	// ignore S8x becuase it's not compatible with FT2 panning
	412	else if (tmp == 0xB) ton.eff \|= 0x60;
	413	else if (tmp == 0xC) // Note Cut
	414	{
	415	ton.eff \|= 0xC0;
	416	if (ton.eff == 0xC0)
	417	{
	418	// EC0 does nothing in ST3 but cuts voice in FT2, remove effect
	419	ton.effTyp = 0;
	420	ton.eff = 0;
	421	}
	422	}
	423	else if (tmp == 0xD) // Note Delay
	424	{
	425	ton.eff \|= 0xD0;
	426	if (ton.ton == 0 \|\| ton.ton == 97)
	427	{
	428	// EDx without a note does nothing in ST3 but retrigs in FT2, remove effect
	429	ton.effTyp = 0;
	430	ton.eff = 0;
	431	}
	432	else if (ton.eff == 0xD0)
	433	{
	434	// ED0 prevents note/smp/vol from updating in ST3, remove everything
	435	ton.ton = 0;
	436	ton.instr = 0;
	437	ton.vol = 0;
	438	ton.effTyp = 0;
	439	ton.eff = 0;
	440	}
	441	}
	442	else if (tmp == 0xE) ton.eff \|= 0xE0;
	443	else if (tmp == 0xF) ton.eff \|= 0xF0;
	444	else
	445	{
	446	ton.effTyp = 0;
	447	ton.eff = 0;
	448	}
	449	}
	450	break;
	451
	452	case 20: // T
	453	{
	454	ton.effTyp = 0x0F;
	455	if (ton.eff < 0x21) // Txx with a value lower than 33 (0x21) does nothing in ST3, remove effect
	456	{
	457	ton.effTyp = 0;
	458	ton.eff = 0;
	459	}
	460	}
	461	break;
	462
	463	case 22: // V
	464	{
	465	ton.effTyp = 0x10;
	466	if (ton.eff > 0x40)
	467	{
	468	// Vxx > 0x40 does nothing in ST3
	469	ton.effTyp = 0;
	470	ton.eff = 0;
	471	}
	472	}
	473	break;
	474
	475	default:
	476	{
	477	ton.effTyp = 0;
	478	ton.eff = 0;
	479	}
	480	break;
	481	}
	482	}
	483
	484	if (ton.instr != 0 && ton.effTyp != 0x3)
	485	s3mLastGInstr[ii] = ton.instr;
	486
	487	if (ton.effTyp > 35)
	488	{
	489	ton.effTyp = 0;
	490	ton.eff = 0;
	491	}
	492
	493	pattTmp[i][(kk * MAX_VOICES) + ii] = ton;
	494	}
	495	}
	496
	497	if (tmpPatternEmpty((uint16_t)i))
	498	{
	499	if (pattTmp[i] != NULL)
	500	{
	501	free(pattTmp[i]);
	502	pattTmp[i] = NULL;
	503	}
	504	}
	505	}
	506	}
	507
	508	// * SAMPLES *
	509
	510	bool adlibInsWarn = false;
	511
	512	memcpy(ptnOfs, ha, 512);
	513	for (i = 0; i < ai; i++)
	514	{
	515	fseek(f, ptnOfs[i] << 4, SEEK_SET);
	516
	517	if (fread(&h_S3MInstr, 1, sizeof (h_S3MInstr), f) != sizeof (h_S3MInstr))
	518	{
	519	loaderMsgBox("Not enough memory!");
	520	return false;
	521	}
	522
	523	memcpy(songTmp.instrName[1+i], h_S3MInstr.name, 22);
	524
	525	if (h_S3MInstr.typ == 2)
	526	{
	527	adlibInsWarn = true;
	528	}
	529	else if (h_S3MInstr.typ == 1)
	530	{
	531	if ((h_S3MInstr.flags & (255-1-2-4)) != 0 \|\| h_S3MInstr.pack != 0)
	532	{
	533	loaderMsgBox("Error loading .s3m: Incompatible module!");
	534	return false;
	535	}
	536	else if (h_S3MInstr.memSeg > 0 && h_S3MInstr.len > 0)
	537	{
	538	if (!allocateTmpInstr((int16_t)(1 + i)))
	539	{
	540	loaderMsgBox("Not enough memory!");
	541	return false;
	542	}
	543
	544	setNoEnvelope(instrTmp[1 + i]);
	545	s = &instrTmp[1+i]->samp[0];
	546
	547	// non-FT2: fixes "miracle man.s3m" and other broken S3Ms
	548	if ((h_S3MInstr.memSeg<<4)+h_S3MInstr.len > (int32_t)filesize)
	549	h_S3MInstr.len = filesize - (h_S3MInstr.memSeg << 4);
	550
	551	len = h_S3MInstr.len;
	552
	553	bool hasLoop = h_S3MInstr.flags & 1;
	554	bool stereoSample = (h_S3MInstr.flags >> 1) & 1;
	555	bool is16Bit = (h_S3MInstr.flags >> 2) & 1;
	556
	557	if (is16Bit) // 16-bit
	558	len <<= 1;
	559
	560	if (stereoSample) // stereo
	561	len <<= 1;
	562
	563	if (!allocateTmpSmpData(s, len))
	564	{
	565	loaderMsgBox("Not enough memory!");
	566	return false;
	567	}
	568
	569	memcpy(s->name, h_S3MInstr.name, 21);
	570
	571	if (h_S3MInstr.c2Spd > 65535) // ST3 (and OpenMPT) does this
	572	h_S3MInstr.c2Spd = 65535;
	573
	574	s->len = h_S3MInstr.len;
	575	s->vol = h_S3MInstr.vol;
	576	s->repS = h_S3MInstr.repS;
	577	s->repL = h_S3MInstr.repE - h_S3MInstr.repS;
	578
	579	tuneSample(s, h_S3MInstr.c2Spd, tmpLinearPeriodsFlag);
	580
	581	if (s->vol > 64)
	582	s->vol = 64;
	583
	584	if (s->repL <= 2 \|\| s->repS+s->repL > s->len \|\| s->repL == 0)
	585	{
	586	s->repS = 0;
	587	s->repL = 0;
	588	hasLoop = false;
	589	}
	590
	591	s->typ = hasLoop + (is16Bit << 4);
	592
	593	fseek(f, h_S3MInstr.memSeg << 4, SEEK_SET);
	594
	595	if (ver == 1)
	596	{
	597	fseek(f, len, SEEK_CUR); // sample not supported
	598	}
	599	else
	600	{
	601	if (fread(s->pek, len, 1, f) != 1)
	602	{
	603	loaderMsgBox("General I/O error during loading! Is the file in use?");
	604	return false;
	605	}
	606
	607	if (is16Bit)
	608	{
	609	conv16BitSample(s->pek, len, stereoSample);
	610
	611	s->len <<= 1;
	612	s->repS <<= 1;
	613	s->repL <<= 1;
	614	}
	615	else
	616	{
	617	conv8BitSample(s->pek, len, stereoSample);
	618	}
	619
	620	// if stereo sample: reduce memory footprint after sample was downmixed to mono
	621	if (stereoSample)
	622	reallocateTmpSmpData(s, s->len);
	623	}
	624	}
	625	}
	626	}
	627
	628	songTmp.antChn = countS3MChannels(ap);
	629
	630	if (adlibInsWarn)
	631	loaderMsgBox("Warning: The module contains unsupported AdLib instruments!");
	632
	633	if (!(config.dontShowAgainFlags & DONT_SHOW_S3M_LOAD_WARNING_FLAG))
	634	loaderSysReq(6, "System message", "Warning: S3M channel panning is ignored because it's not compatible with FT2.");
	635
	636	return true;
	637	}
	638
	639	static int8_t countS3MChannels(uint16_t antPtn)
	640	{
	641	int32_t channels = 0;
	642	for (int32_t i = 0; i < antPtn; i++)
	643	{
	644	if (pattTmp[i] == NULL)
	645	continue;
	646
	647	tonTyp *ton = pattTmp[i];
	648	for (int32_t j = 0; j < 64; j++)
	649	{
	650	for (int32_t k = 0; k < MAX_VOICES; k++, ton++)
	651	{
	652	if (ton->eff == 0 && ton->effTyp == 0 && ton->instr == 0 && ton->ton == 0 && ton->vol == 0)
	653	continue;
	654
	655	if (k > channels)
	656	channels = k;
	657	}
	658	}
	659	}
	660	channels++;
	661
	662	return (int8_t)channels;
	663	}

src/modloaders/ft2_load_stk.c+350−0

@@ -0,0 +1,350 @@
	1	// Ultimate SoundTracker (or compatible) STK loader
	2
	3	#include <stdio.h>
	4	#include <stdint.h>
	5	#include <stdbool.h>
	6	#include "../ft2_header.h"
	7	#include "../ft2_module_loader.h"
	8	#include "../ft2_sample_ed.h"
	9	#include "../ft2_tables.h"
	10	#include "../ft2_sysreqs.h"
	11
	12	#ifdef _MSC_VER // please don't mess with this struct!
	13	#pragma pack(push)
	14	#pragma pack(1)
	15	#endif
	16	typedef struct songMOD15HeaderTyp_t
	17	{
	18	char name[20];
	19	songMODInstrHeaderTyp instr[15];
	20	uint8_t len, CIAVal, songTab[128];
	21	}
	22	#ifdef __GNUC__
	23	__attribute__ ((packed))
	24	#endif
	25	songMOD15HeaderTyp;
	26	#ifdef _MSC_VER
	27	#pragma pack(pop)
	28	#endif
	29
	30	bool loadSTK(FILE *f, uint32_t filesize)
	31	{
	32	uint8_t bytes[4];
	33	int16_t i, j, k;
	34	uint16_t a, b, period;
	35	tonTyp *ton;
	36	sampleTyp *s;
	37	songMOD15HeaderTyp h_MOD15;
	38
	39	tmpLinearPeriodsFlag = false; // use Amiga periods
	40
	41	bool veryLateSTKVerFlag = false; // "DFJ SoundTracker III" nad later
	42	bool lateSTKVerFlag = false; // "TJC SoundTracker II" and later
	43
	44	if (filesize < sizeof (h_MOD15))
	45	{
	46	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	47	return false;
	48	}
	49
	50	memset(&h_MOD15, 0, sizeof (songMOD15HeaderTyp));
	51	if (fread(&h_MOD15, 1, sizeof (h_MOD15), f) != sizeof (h_MOD15))
	52	{
	53	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	54	return false;
	55	}
	56
	57	if (h_MOD15.CIAVal == 0) // a CIA value of 0 results in 120
	58	h_MOD15.CIAVal = 120;
	59
	60	songTmp.antChn = 4;
	61	songTmp.len = h_MOD15.len;
	62	songTmp.speed = 125;
	63	songTmp.initialTempo = songTmp.tempo = 6;
	64	memcpy(songTmp.songTab, h_MOD15.songTab, 128);
	65
	66	if (songTmp.len < 1 \|\| songTmp.len > 128 \|\| h_MOD15.CIAVal > 220)
	67	{
	68	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	69	return false;
	70	}
	71
	72	for (a = 0; a < 15; a++)
	73	{
	74	songMODInstrHeaderTyp *smp = &h_MOD15.instr[a];
	75	memcpy(songTmp.instrName[1+a], smp->name, 22);
	76
	77	/* Only late versions of Ultimate SoundTracker supports samples larger than 9999 bytes.
	78	** If found, we know for sure that this is a late STK module.
	79	*/
	80	const int32_t sampleLen = 2*SWAP16(smp->len);
	81	if (sampleLen > 9999)
	82	lateSTKVerFlag = true;
	83	}
	84
	85	// jjk55.mod by Jesper Kyd has a bogus STK tempo value that should be ignored (hackish!)
	86	if (!strcmp("jjk55", h_MOD15.name))
	87	h_MOD15.CIAVal = 120;
	88
	89	if (h_MOD15.CIAVal != 120) // 120 is a special case and means 50Hz (125BPM)
	90	{
	91	// convert UST tempo to BPM
	92	uint16_t ciaPeriod = (240 - h_MOD15.CIAVal) * 122;
	93	double dHz = 709379.0 / ciaPeriod;
	94	int32_t BPM = (int32_t)((dHz * 2.5) + 0.5);
	95
	96	songTmp.speed = (uint16_t)BPM;
	97	}
	98
	99	memcpy(songTmp.name, h_MOD15.name, 20);
	100
	101	// count number of patterns
	102	b = 0;
	103	for (a = 0; a < 128; a++)
	104	{
	105	if (songTmp.songTab[a] > b)
	106	b = songTmp.songTab[a];
	107	}
	108	b++;
	109
	110	for (a = 0; a < b; a++)
	111	{
	112	if (!allocateTmpPatt(a, 64))
	113	{
	114	loaderMsgBox("Not enough memory!");
	115	return false;
	116	}
	117
	118	for (j = 0; j < 64; j++)
	119	{
	120	for (k = 0; k < songTmp.antChn; k++)
	121	{
	122	ton = &pattTmp[a][(j * MAX_VOICES) + k];
	123
	124	if (fread(bytes, 1, 4, f) != 4)
	125	{
	126	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	127	return false;
	128	}
	129
	130	// period to note
	131	period = ((bytes[0] & 0x0F) << 8) \| bytes[1];
	132	for (i = 0; i < 3*12; i++)
	133	{
	134	if (period >= ptPeriods[i])
	135	{
	136	ton->ton = 1 + (3*12) + (uint8_t)i;
	137	break;
	138	}
	139	}
	140
	141	ton->instr = (bytes[0] & 0xF0) \| (bytes[2] >> 4);
	142	ton->effTyp = bytes[2] & 0x0F;
	143	ton->eff = bytes[3];
	144
	145	if (ton->effTyp == 0xC \|\| ton->effTyp == 0xD \|\| ton->effTyp == 0xE)
	146	{
	147	// "TJC SoundTracker II" and later
	148	lateSTKVerFlag = true;
	149	}
	150
	151	if (ton->effTyp == 0xF)
	152	{
	153	// "DFJ SoundTracker III" and later
	154	lateSTKVerFlag = true;
	155	veryLateSTKVerFlag = true;
	156	}
	157
	158	if (ton->effTyp == 0xC)
	159	{
	160	if (ton->eff > 64)
	161	ton->eff = 64;
	162	}
	163	else if (ton->effTyp == 0x1)
	164	{
	165	if (ton->eff == 0)
	166	ton->effTyp = 0;
	167	}
	168	else if (ton->effTyp == 0x2)
	169	{
	170	if (ton->eff == 0)
	171	ton->effTyp = 0;
	172	}
	173	else if (ton->effTyp == 0x5)
	174	{
	175	if (ton->eff == 0)
	176	ton->effTyp = 0x3;
	177	}
	178	else if (ton->effTyp == 0x6)
	179	{
	180	if (ton->eff == 0)
	181	ton->effTyp = 0x4;
	182	}
	183	else if (ton->effTyp == 0xA)
	184	{
	185	if (ton->eff == 0)
	186	ton->effTyp = 0;
	187	}
	188	else if (ton->effTyp == 0xE)
	189	{
	190	// check if certain E commands are empty
	191	if (ton->eff == 0x10 \|\| ton->eff == 0x20 \|\| ton->eff == 0xA0 \|\| ton->eff == 0xB0)
	192	{
	193	ton->effTyp = 0;
	194	ton->eff = 0;
	195	}
	196	}
	197	}
	198	}
	199
	200	if (tmpPatternEmpty(a))
	201	{
	202	if (pattTmp[a] != NULL)
	203	{
	204	free(pattTmp[a]);
	205	pattTmp[a] = NULL;
	206	}
	207	}
	208	}
	209
	210	// pattern command conversion for non-PT formats
	211	for (a = 0; a < b; a++)
	212	{
	213	if (pattTmp[a] == NULL)
	214	continue;
	215
	216	for (j = 0; j < 64; j++)
	217	{
	218	for (k = 0; k < songTmp.antChn; k++)
	219	{
	220	ton = &pattTmp[a][(j * MAX_VOICES) + k];
	221
	222	// convert STK effects to PT effects
	223
	224	if (!lateSTKVerFlag)
	225	{
	226	// old SoundTracker 1.x commands
	227
	228	if (ton->effTyp == 1)
	229	{
	230	// arpeggio
	231	ton->effTyp = 0;
	232	}
	233	else if (ton->effTyp == 2)
	234	{
	235	// pitch slide
	236	if (ton->eff & 0xF0)
	237	{
	238	// pitch slide down
	239	ton->effTyp = 2;
	240	ton->eff >>= 4;
	241	}
	242	else if (ton->eff & 0x0F)
	243	{
	244	// pitch slide up
	245	ton->effTyp = 1;
	246	}
	247	}
	248	}
	249	else
	250	{
	251	// "DFJ SoundTracker II" or later
	252
	253	if (ton->effTyp == 0xD)
	254	{
	255	if (veryLateSTKVerFlag) // "DFJ SoundTracker III" or later
	256	{
	257	// pattern break w/ no param (param must be cleared to fix some songs)
	258	ton->eff = 0;
	259	}
	260	else
	261	{
	262	// volume slide
	263	ton->effTyp = 0xA;
	264	}
	265	}
	266	}
	267
	268	// effect F with param 0x00 does nothing in UST/STK (I think)
	269	if (ton->effTyp == 0xF && ton->eff == 0)
	270	ton->effTyp = 0;
	271	}
	272	}
	273	}
	274
	275	for (a = 0; a < 15; a++)
	276	{
	277	if (h_MOD15.instr[a].len == 0)
	278	continue;
	279
	280	if (!allocateTmpInstr(1+a))
	281	{
	282	loaderMsgBox("Not enough memory!");
	283	return false;
	284	}
	285
	286	setNoEnvelope(instrTmp[1+a]);
	287
	288	s = &instrTmp[1+a]->samp[0];
	289	s->vol = h_MOD15.instr[a].vol;
	290
	291	s->len = 2 * SWAP16(h_MOD15.instr[a].len);
	292	s->repS = SWAP16(h_MOD15.instr[a].repS); // in STK, loopStart = bytes, not words
	293	s->repL = 2 * SWAP16(h_MOD15.instr[a].repL);
	294
	295	if (s->vol > 64)
	296	s->vol = 64;
	297
	298	if (s->repL < 2)
	299	s->repL = 2;
	300
	301	// fix overflown loop
	302	if (s->repS+s->repL > s->len)
	303	{
	304	if (s->repS >= s->len)
	305	{
	306	s->repS = 0;
	307	s->repL = 0;
	308	}
	309	else
	310	{
	311	s->repL = s->len - s->repS;
	312	}
	313	}
	314
	315	if (s->repS+s->repL > 2)
	316	{
	317	s->typ = 1; // enable loop
	318	}
	319	else
	320	{
	321	s->repL = 0;
	322	s->repS = 0;
	323	}
	324
	325	/* In STK, only the loop area of a looped sample is played.
	326	** Skip loading of eventual data present before loop start.
	327	*/
	328	if (s->repS > 0 && s->repL < s->len)
	329	{
	330	s->len -= s->repS;
	331	fseek(f, s->repS, SEEK_CUR);
	332	s->repS = 0;
	333	}
	334
	335	if (!allocateTmpSmpData(s, s->len))
	336	{
	337	loaderMsgBox("Not enough memory!");
	338	return false;
	339	}
	340
	341	int32_t bytesRead = (int32_t)fread(s->pek, 1, s->len, f);
	342	if (bytesRead < s->len)
	343	{
	344	int32_t bytesToClear = s->len - bytesRead;
	345	memset(&s->pek[bytesRead], 0, bytesToClear);
	346	}
	347	}
	348
	349	return true;
	350	}

src/modloaders/ft2_load_stm.c+263−0

@@ -0,0 +1,263 @@
	1	// Scream Tracker 2 STM loader
	2
	3	#include <stdio.h>
	4	#include <stdint.h>
	5	#include <stdbool.h>
	6	#include "../ft2_header.h"
	7	#include "../ft2_module_loader.h"
	8	#include "../ft2_sample_ed.h"
	9	#include "../ft2_tables.h"
	10	#include "../ft2_sysreqs.h"
	11
	12	#ifdef _MSC_VER // please don't mess with these structs!
	13	#pragma pack(push)
	14	#pragma pack(1)
	15	#endif
	16	typedef struct songSTMinstrHeaderTyp_t
	17	{
	18	char name[12];
	19	uint8_t nul, insDisk;
	20	uint16_t reserved1, len, repS, repE;
	21	uint8_t vol, reserved2;
	22	uint16_t rate;
	23	int32_t reserved3;
	24	uint16_t paraLen;
	25	}
	26	#ifdef __GNUC__
	27	__attribute__ ((packed))
	28	#endif
	29	songSTMinstrHeaderTyp;
	30
	31	typedef struct songSTMHeaderTyp_t
	32	{
	33	char name[20], sig[8];
	34	uint8_t id1a, typ;
	35	uint8_t verMajor, verMinor;
	36	uint8_t tempo, ap, vol, reserved[13];
	37	songSTMinstrHeaderTyp instr[31];
	38	uint8_t songTab[128];
	39	}
	40	#ifdef __GNUC__
	41	__attribute__ ((packed))
	42	#endif
	43	songSTMHeaderTyp;
	44	#ifdef _MSC_VER
	45	#pragma pack(pop)
	46	#endif
	47
	48	static const uint8_t stmEff[16] = { 0, 0, 11, 0, 10, 2, 1, 3, 4, 7, 0, 5, 6, 0, 0, 0 };
	49
	50	static uint8_t stmTempoToBPM(uint8_t tempo);
	51
	52	bool loadSTM(FILE *f, uint32_t filesize)
	53	{
	54	uint8_t typ, tempo, pattBuff[1024];
	55	int16_t i, j, k, ap, tmp;
	56	uint16_t a;
	57	tonTyp *ton;
	58	sampleTyp *s;
	59	songSTMHeaderTyp h_STM;
	60
	61	tmpLinearPeriodsFlag = false; // use Amiga periods
	62
	63	if (filesize < sizeof (h_STM))
	64	{
	65	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	66	return false;
	67	}
	68
	69	if (fread(&h_STM, 1, sizeof (h_STM), f) != sizeof (h_STM))
	70	{
	71	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	72	return false;
	73	}
	74
	75	if (h_STM.verMinor == 0 \|\| h_STM.typ != 2)
	76	{
	77	loaderMsgBox("Error loading STM: Incompatible module!");
	78	return false;
	79	}
	80
	81	songTmp.antChn = 4;
	82	memcpy(songTmp.songTab, h_STM.songTab, 128);
	83
	84	i = 0;
	85	while (i < 128 && songTmp.songTab[i] < 99) i++;
	86	songTmp.len = i + (i == 0);
	87
	88	if (songTmp.len < 255)
	89	memset(&songTmp.songTab[songTmp.len], 0, 256 - songTmp.len);
	90
	91	memcpy(songTmp.name, h_STM.name, 20);
	92
	93	tempo = h_STM.tempo;
	94	if (h_STM.verMinor < 21)
	95	tempo = ((tempo / 10) << 4) + (tempo % 10);
	96
	97	if (tempo == 0)
	98	tempo = 96;
	99
	100	songTmp.initialTempo = songTmp.tempo = CLAMP(h_STM.tempo >> 4, 1, 31);
	101	songTmp.speed = stmTempoToBPM(tempo);
	102
	103	if (h_STM.verMinor > 10)
	104	songTmp.globVol = MIN(h_STM.vol, 64);
	105
	106	ap = h_STM.ap;
	107	for (i = 0; i < ap; i++)
	108	{
	109	if (!allocateTmpPatt(i, 64))
	110	{
	111	loaderMsgBox("Not enough memory!");
	112	return false;
	113	}
	114
	115	if (fread(pattBuff, 64 * 4 * 4, 1, f) != 1)
	116	{
	117	loaderMsgBox("General I/O error during loading!");
	118	return false;
	119	}
	120
	121	a = 0;
	122	for (j = 0; j < 64; j++)
	123	{
	124	for (k = 0; k < 4; k++)
	125	{
	126	ton = &pattTmp[i][(j * MAX_VOICES) + k];
	127
	128	if (pattBuff[a] == 254)
	129	{
	130	ton->ton = 97;
	131	}
	132	else if (pattBuff[a] < 96)
	133	{
	134	ton->ton = (12 * (pattBuff[a] >> 4)) + (25 + (pattBuff[a] & 0x0F));
	135	if (ton->ton > 96)
	136	ton->ton = 0;
	137	}
	138	else
	139	{
	140	ton->ton = 0;
	141	}
	142
	143	ton->instr = pattBuff[a + 1] >> 3;
	144	typ = (pattBuff[a + 1] & 7) + ((pattBuff[a + 2] & 0xF0) >> 1);
	145	if (typ <= 64)
	146	ton->vol = typ + 0x10;
	147
	148	ton->eff = pattBuff[a + 3];
	149
	150	tmp = pattBuff[a + 2] & 0x0F;
	151	if (tmp == 1)
	152	{
	153	ton->effTyp = 15;
	154
	155	if (h_STM.verMinor < 21)
	156	ton->eff = ((ton->eff / 10) << 4) + (ton->eff % 10);
	157
	158	ton->eff >>= 4;
	159	}
	160	else if (tmp == 3)
	161	{
	162	ton->effTyp = 13;
	163	ton->eff = 0;
	164	}
	165	else if (tmp == 2 \|\| (tmp >= 4 && tmp <= 12))
	166	{
	167	ton->effTyp = stmEff[tmp];
	168	if (ton->effTyp == 0xA)
	169	{
	170	if (ton->eff & 0x0F)
	171	ton->eff &= 0x0F;
	172	else
	173	ton->eff &= 0xF0;
	174	}
	175	}
	176	else
	177	{
	178	ton->eff = 0;
	179	}
	180
	181	if (ton->effTyp > 35)
	182	{
	183	ton->effTyp = 0;
	184	ton->eff = 0;
	185	}
	186
	187	a += 4;
	188	}
	189	}
	190
	191	if (tmpPatternEmpty(i))
	192	{
	193	if (pattTmp[i] != NULL)
	194	{
	195	free(pattTmp[i]);
	196	pattTmp[i] = NULL;
	197	}
	198	}
	199	}
	200
	201	for (i = 0; i < 31; i++)
	202	{
	203	memcpy(&songTmp.instrName[1+i], h_STM.instr[i].name, 12);
	204
	205	if (h_STM.instr[i].len != 0 && h_STM.instr[i].reserved1 != 0)
	206	{
	207	allocateTmpInstr(1 + i);
	208	setNoEnvelope(instrTmp[i]);
	209
	210	s = &instrTmp[1+i]->samp[0];
	211
	212	if (!allocateTmpSmpData(s, h_STM.instr[i].len))
	213	{
	214	loaderMsgBox("Not enough memory!");
	215	return false;
	216	}
	217
	218	s->len = h_STM.instr[i].len;
	219	s->vol = h_STM.instr[i].vol;
	220	s->repS = h_STM.instr[i].repS;
	221	s->repL = h_STM.instr[i].repE - h_STM.instr[i].repS;
	222
	223	memcpy(s->name, h_STM.instr[i].name, 12);
	224	tuneSample(s, h_STM.instr[i].rate, tmpLinearPeriodsFlag);
	225
	226	if (s->repS < s->len && h_STM.instr[i].repE > s->repS && h_STM.instr[i].repE != 0xFFFF)
	227	{
	228	if (s->repS+s->repL > s->len)
	229	s->repL = s->len - s->repS;
	230
	231	s->typ = 1; // enable loop
	232	}
	233	else
	234	{
	235	s->repS = 0;
	236	s->repL = 0;
	237	s->typ = 0;
	238	}
	239
	240	if (s->vol > 64)
	241	s->vol = 64;
	242
	243	if (fread(s->pek, s->len, 1, f) != 1)
	244	{
	245	loaderMsgBox("General I/O error during loading! Possibly corrupt module?");
	246	return false;
	247	}
	248	}
	249	}
	250
	251	return true;
	252	}
	253
	254	static uint8_t stmTempoToBPM(uint8_t tempo) // ported from original ST2.3 replayer code
	255	{
	256	const uint8_t slowdowns[16] = { 140, 50, 25, 15, 10, 7, 6, 4, 3, 3, 2, 2, 2, 2, 1, 1 };
	257	uint16_t hz = 50;
	258
	259	hz -= ((slowdowns[tempo >> 4] * (tempo & 15)) >> 4); // can and will underflow
	260
	261	const uint32_t bpm = (hz << 1) + (hz >> 1); // BPM = hz * 2.5
	262	return (uint8_t)CLAMP(bpm, 32, 255); // result can be slightly off, but close enough...
	263	}

src/modloaders/ft2_load_xm.c+626−0

@@ -0,0 +1,626 @@
	1	// Fasttracker II (or compatible) XM loader
	2
	3	#include <stdio.h>
	4	#include <stdint.h>
	5	#include <stdbool.h>
	6	#include "../ft2_header.h"
	7	#include "../ft2_module_loader.h"
	8	#include "../ft2_sample_ed.h"
	9	#include "../ft2_tables.h"
	10	#include "../ft2_sysreqs.h"
	11
	12	static uint8_t packedPattData[65536];
	13
	14	/* ModPlug Tracker & OpenMPT supports up to 32 samples per instrument for XMs - we don't.
	15	** For such modules, we use a temporary array here to store the extra sample data lengths
	16	** we need to skip to be able to load the file (we lose the extra samples, though...).
	17	*/
	18	static uint32_t extraSampleLengths[32-MAX_SMP_PER_INST];
	19
	20	static bool loadInstrHeader(FILE *f, uint16_t i);
	21	static bool loadInstrSample(FILE *f, uint16_t i);
	22	static void unpackPatt(uint8_t dst, uint8_t src, uint16_t len, int32_t antChn);
	23	static bool loadPatterns(FILE *f, uint16_t antPtn);
	24	static void unpackPatt(uint8_t dst, uint8_t src, uint16_t len, int32_t antChn);
	25	static void sanitizeInstrument(instrTyp *ins);
	26
	27	bool loadXM(FILE *f, uint32_t filesize)
	28	{
	29	uint16_t i;
	30	songHeaderTyp h;
	31
	32	if (filesize < sizeof (h))
	33	{
	34	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	35	return false;
	36	}
	37
	38	if (fread(&h, 1, sizeof (h), f) != sizeof (h))
	39	{
	40	loaderMsgBox("Error: This file is either not a module, or is not supported.");
	41	return false;
	42	}
	43
	44	if (h.ver < 0x0102 \|\| h.ver > 0x0104)
	45	{
	46	loaderMsgBox("Error loading XM: Unsupported file version (v%01X.%02X).", (h.ver >> 8) & 15, h.ver & 0xFF);
	47	return false;
	48	}
	49
	50	if (h.len > MAX_ORDERS)
	51	{
	52	loaderMsgBox("Error loading XM: The song has more than 256 orders!");
	53	return false;
	54	}
	55
	56	if (h.antPtn > MAX_PATTERNS)
	57	{
	58	loaderMsgBox("Error loading XM: The song has more than 256 patterns!");
	59	return false;
	60	}
	61
	62	if (h.antChn == 0)
	63	{
	64	loaderMsgBox("Error loading XM: This file is corrupt.");
	65	return false;
	66	}
	67
	68	if (h.antInstrs > 256) // if >128 instruments, we fake-load up to 128 extra instruments and discard them
	69	{
	70	loaderMsgBox("Error loading XM: This file is corrupt.");
	71	return false;
	72	}
	73
	74	fseek(f, 60 + h.headerSize, SEEK_SET);
	75	if (filesize != 336 && feof(f)) // 336 in length at this point = empty XM
	76	{
	77	loaderMsgBox("Error loading XM: The module is empty!");
	78	return false;
	79	}
	80
	81	memcpy(songTmp.name, h.name, 20);
	82
	83	songTmp.len = h.len;
	84	songTmp.repS = h.repS;
	85	songTmp.antChn = (uint8_t)h.antChn;
	86	songTmp.speed = h.defSpeed;
	87	songTmp.tempo = h.defTempo;
	88	songTmp.ver = h.ver;
	89	tmpLinearPeriodsFlag = h.flags & 1;
	90
	91	// non-FT2: clamp to max numbers that are okay for GUI
	92	songTmp.speed = CLAMP(songTmp.speed, 1, 999);
	93	songTmp.initialTempo = songTmp.tempo = CLAMP(songTmp.tempo, 1, 99);
	94
	95	if (songTmp.len == 0)
	96	songTmp.len = 1; // songTmp.songTab is already empty
	97	else
	98	memcpy(songTmp.songTab, h.songTab, songTmp.len);
	99
	100	// some strange XMs have the order list padded with 0xFF, remove them!
	101	for (int16_t j = 255; j >= 0; j--)
	102	{
	103	if (songTmp.songTab[j] != 0xFF)
	104	break;
	105
	106	if (songTmp.len > j)
	107	songTmp.len = j;
	108	}
	109
	110	// even though XM supports 256 orders, FT2 supports only 255...
	111	if (songTmp.len > 0xFF)
	112	songTmp.len = 0xFF;
	113
	114	if (songTmp.ver < 0x0104)
	115	{
	116	// XM v1.02 and XM v1.03
	117
	118	for (i = 1; i <= h.antInstrs; i++)
	119	{
	120	if (!loadInstrHeader(f, i))
	121	return false;
	122	}
	123
	124	if (!loadPatterns(f, h.antPtn))
	125	return false;
	126
	127	for (i = 1; i <= h.antInstrs; i++)
	128	{
	129	if (!loadInstrSample(f, i))
	130	return false;
	131	}
	132	}
	133	else
	134	{
	135	// XM v1.04 (latest version)
	136
	137	if (!loadPatterns(f, h.antPtn))
	138	return false;
	139
	140	for (i = 1; i <= h.antInstrs; i++)
	141	{
	142	if (!loadInstrHeader(f, i))
	143	return false;
	144
	145	if (!loadInstrSample(f, i))
	146	return false;
	147	}
	148	}
	149
	150	// if we temporarily loaded more than 128 instruments, clear the extra allocated memory
	151	if (h.antInstrs > MAX_INST)
	152	{
	153	for (i = MAX_INST+1; i <= h.antInstrs; i++)
	154	{
	155	if (instrTmp[i] != NULL)
	156	{
	157	free(instrTmp[i]);
	158	instrTmp[i] = NULL;
	159	}
	160	}
	161	}
	162
	163	/* We support loading XMs with up to 32 samples per instrument (ModPlug/OpenMPT),
	164	** but only the first 16 will be loaded. Now make sure we set the number of samples
	165	** back to max 16 in the headers before loading is done.
	166	*/
	167	bool instrHasMoreThan16Samples = false;
	168	for (i = 1; i <= MAX_INST; i++)
	169	{
	170	if (instrTmp[i] != NULL && instrTmp[i]->antSamp > MAX_SMP_PER_INST)
	171	{
	172	instrHasMoreThan16Samples = true;
	173	instrTmp[i]->antSamp = MAX_SMP_PER_INST;
	174	}
	175	}
	176
	177	if (songTmp.antChn > MAX_VOICES)
	178	{
	179	songTmp.antChn = MAX_VOICES;
	180	loaderMsgBox("Warning: This XM contains >32 channels. The extra channels will be discarded!");
	181	}
	182
	183	if (h.antInstrs > MAX_INST)
	184	loaderMsgBox("Warning: This XM contains >128 instruments. The extra instruments will be discarded!");
	185
	186	if (instrHasMoreThan16Samples)
	187	loaderMsgBox("Warning: This XM contains instrument(s) with >16 samples. The extra samples will be discarded!");
	188
	189	return true;
	190	}
	191
	192	static bool loadInstrHeader(FILE *f, uint16_t i)
	193	{
	194	uint8_t j;
	195	uint32_t readSize;
	196	instrHeaderTyp ih;
	197	instrTyp *ins;
	198	sampleHeaderTyp *src;
	199	sampleTyp *s;
	200
	201	memset(extraSampleLengths, 0, sizeof (extraSampleLengths));
	202	memset(&ih, 0, sizeof (ih));
	203	fread(&ih.instrSize, 4, 1, f);
	204
	205	readSize = ih.instrSize;
	206
	207	// yes, some XMs can have a header size of 0, and it usually means 263 bytes (INSTR_HEADER_SIZE)
	208	if (readSize == 0 \|\| readSize > INSTR_HEADER_SIZE)
	209	readSize = INSTR_HEADER_SIZE;
	210
	211	if (readSize < 4)
	212	{
	213	loaderMsgBox("Error loading XM: This file is corrupt (or not supported)!");
	214	return false;
	215	}
	216
	217	// load instrument data into temp buffer
	218	fread(ih.name, readSize-4, 1, f); // -4 = skip ih.instrSize
	219
	220	// FT2 bugfix: skip instrument header data if instrSize is above INSTR_HEADER_SIZE
	221	if (ih.instrSize > INSTR_HEADER_SIZE)
	222	fseek(f, ih.instrSize-INSTR_HEADER_SIZE, SEEK_CUR);
	223
	224	if (ih.antSamp < 0 \|\| ih.antSamp > 32)
	225	{
	226	loaderMsgBox("Error loading XM: This file is corrupt (or not supported)!");
	227	return false;
	228	}
	229
	230	if (i <= MAX_INST) // copy over instrument names
	231	memcpy(songTmp.instrName[i], ih.name, 22);
	232
	233	if (ih.antSamp > 0)
	234	{
	235	if (!allocateTmpInstr(i))
	236	{
	237	loaderMsgBox("Not enough memory!");
	238	return false;
	239	}
	240
	241	// copy instrument header elements to our instrument struct
	242
	243	ins = instrTmp[i];
	244	memcpy(ins->ta, ih.ta, 96);
	245	memcpy(ins->envVP, ih.envVP, 122sizeof(int16_t));
	246	memcpy(ins->envPP, ih.envPP, 122sizeof(int16_t));
	247	ins->envVPAnt = ih.envVPAnt;
	248	ins->envPPAnt = ih.envPPAnt;
	249	ins->envVSust = ih.envVSust;
	250	ins->envVRepS = ih.envVRepS;
	251	ins->envVRepE = ih.envVRepE;
	252	ins->envPSust = ih.envPSust;
	253	ins->envPRepS = ih.envPRepS;
	254	ins->envPRepE = ih.envPRepE;
	255	ins->envVTyp = ih.envVTyp;
	256	ins->envPTyp = ih.envPTyp;
	257	ins->vibTyp = ih.vibTyp;
	258	ins->vibSweep = ih.vibSweep;
	259	ins->vibDepth = ih.vibDepth;
	260	ins->vibRate = ih.vibRate;
	261	ins->fadeOut = ih.fadeOut;
	262	ins->midiOn = (ih.midiOn == 1) ? true : false;
	263	ins->midiChannel = ih.midiChannel;
	264	ins->midiProgram = ih.midiProgram;
	265	ins->midiBend = ih.midiBend;
	266	ins->mute = (ih.mute == 1) ? true : false; // correct logic, don't change this!
	267	ins->antSamp = ih.antSamp; // used in loadInstrSample()
	268
	269	sanitizeInstrument(ins);
	270
	271	int32_t sampleHeadersToRead = ih.antSamp;
	272	if (sampleHeadersToRead > MAX_SMP_PER_INST)
	273	sampleHeadersToRead = MAX_SMP_PER_INST;
	274
	275	if (fread(ih.samp, sampleHeadersToRead * sizeof (sampleHeaderTyp), 1, f) != 1)
	276	{
	277	loaderMsgBox("General I/O error during loading!");
	278	return false;
	279	}
	280
	281	// if instrument contains more than 16 sample headers (unsupported), skip them
	282	if (ih.antSamp > MAX_SMP_PER_INST) // can only be 0..32 at this point
	283	{
	284	const int32_t samplesToSkip = ih.antSamp-MAX_SMP_PER_INST;
	285	for (j = 0; j < samplesToSkip; j++)
	286	{
	287	fread(&extraSampleLengths[j], 4, 1, f); // used for skipping data in loadInstrSample()
	288	fseek(f, sizeof (sampleHeaderTyp)-4, SEEK_CUR);
	289	}
	290	}
	291
	292	for (j = 0; j < sampleHeadersToRead; j++)
	293	{
	294	s = &instrTmp[i]->samp[j];
	295	src = &ih.samp[j];
	296
	297	// copy sample header elements to our sample struct
	298
	299	s->len = src->len;
	300	s->repS = src->repS;
	301	s->repL = src->repL;
	302	s->vol = src->vol;
	303	s->fine = src->fine;
	304	s->typ = src->typ;
	305	s->pan = src->pan;
	306	s->relTon = src->relTon;
	307	memcpy(s->name, src->name, 22);
	308
	309	// dst->pek is set up later
	310
	311	// sanitize stuff broken/unsupported samples (FT2 doesn't do this, but we do!)
	312	if (s->vol > 64)
	313	s->vol = 64;
	314
	315	s->relTon = CLAMP(s->relTon, -48, 71);
	316	}
	317	}
	318
	319	return true;
	320	}
	321
	322	static bool loadInstrSample(FILE *f, uint16_t i)
	323	{
	324	if (instrTmp[i] == NULL)
	325	return true; // empty instrument, let's just pretend it got loaded successfully
	326
	327	uint16_t k = instrTmp[i]->antSamp;
	328	if (k > MAX_SMP_PER_INST)
	329	k = MAX_SMP_PER_INST;
	330
	331	sampleTyp *s = instrTmp[i]->samp;
	332
	333	if (i > MAX_INST) // insNum > 128, just skip sample data
	334	{
	335	for (uint16_t j = 0; j < k; j++, s++)
	336	{
	337	if (s->len > 0)
	338	fseek(f, s->len, SEEK_CUR);
	339	}
	340	}
	341	else
	342	{
	343	for (uint16_t j = 0; j < k; j++, s++)
	344	{
	345	// FT2: a sample with both forward loop and pingpong loop set results in pingpong
	346	if ((s->typ & 3) == 3)
	347	s->typ &= 0xFE; // remove forward loop flag
	348
	349	int32_t l = s->len;
	350	if (l <= 0)
	351	{
	352	s->len = 0;
	353	s->repL = 0;
	354	s->repS = 0;
	355
	356	if (s->typ & 32) // remove stereo flag if present
	357	s->typ &= ~32;
	358	}
	359	else
	360	{
	361	int32_t bytesToSkip = 0;
	362	if (l > MAX_SAMPLE_LEN)
	363	{
	364	bytesToSkip = l - MAX_SAMPLE_LEN;
	365	l = MAX_SAMPLE_LEN;
	366	}
	367
	368	if (!allocateTmpSmpData(s, l))
	369	{
	370	loaderMsgBox("Not enough memory!");
	371	return false;
	372	}
	373
	374	const int32_t bytesRead = (int32_t)fread(s->pek, 1, l, f);
	375	if (bytesRead < l)
	376	{
	377	const int32_t bytesToClear = l - bytesRead;
	378	memset(&s->pek[bytesRead], 0, bytesToClear);
	379	}
	380
	381	if (bytesToSkip > 0)
	382	fseek(f, bytesToSkip, SEEK_CUR);
	383
	384	delta2Samp(s->pek, l, s->typ);
	385
	386	if (s->typ & 32) // stereo sample - already downmixed to mono in delta2samp()
	387	{
	388	s->typ &= ~32; // remove stereo flag
	389
	390	s->len >>= 1;
	391	s->repL >>= 1;
	392	s->repS >>= 1;
	393
	394	reallocateTmpSmpData(s, s->len); // dealloc unused memory
	395	}
	396	}
	397
	398	// NON-FT2 FIX: Align to 2-byte if 16-bit sample
	399	if (s->typ & 16)
	400	{
	401	s->repL &= 0xFFFFFFFE;
	402	s->repS &= 0xFFFFFFFE;
	403	s->len &= 0xFFFFFFFE;
	404	}
	405	}
	406	}
	407
	408	if (instrTmp[i]->antSamp > MAX_SMP_PER_INST)
	409	{
	410	const int32_t samplesToSkip = instrTmp[i]->antSamp-MAX_SMP_PER_INST;
	411	for (i = 0; i < samplesToSkip; i++)
	412	{
	413	if (extraSampleLengths[i] > 0)
	414	fseek(f, extraSampleLengths[i], SEEK_CUR);
	415	}
	416	}
	417
	418	return true;
	419	}
	420
	421	static bool loadPatterns(FILE *f, uint16_t antPtn)
	422	{
	423	uint8_t tmpLen;
	424	patternHeaderTyp ph;
	425
	426	bool pattLenWarn = false;
	427	for (uint16_t i = 0; i < antPtn; i++)
	428	{
	429	if (fread(&ph.patternHeaderSize, 4, 1, f) != 1)
	430	goto pattCorrupt;
	431
	432	if (fread(&ph.typ, 1, 1, f) != 1)
	433	goto pattCorrupt;
	434
	435	ph.pattLen = 0;
	436	if (songTmp.ver == 0x0102)
	437	{
	438	if (fread(&tmpLen, 1, 1, f) != 1)
	439	goto pattCorrupt;
	440
	441	if (fread(&ph.dataLen, 2, 1, f) != 1)
	442	goto pattCorrupt;
	443
	444	ph.pattLen = tmpLen + 1; // +1 in v1.02
	445
	446	if (ph.patternHeaderSize > 8)
	447	fseek(f, ph.patternHeaderSize - 8, SEEK_CUR);
	448	}
	449	else
	450	{
	451	if (fread(&ph.pattLen, 2, 1, f) != 1)
	452	goto pattCorrupt;
	453
	454	if (fread(&ph.dataLen, 2, 1, f) != 1)
	455	goto pattCorrupt;
	456
	457	if (ph.patternHeaderSize > 9)
	458	fseek(f, ph.patternHeaderSize - 9, SEEK_CUR);
	459	}
	460
	461	if (feof(f))
	462	goto pattCorrupt;
	463
	464	pattLensTmp[i] = ph.pattLen;
	465	if (pattLensTmp[i] > MAX_PATT_LEN)
	466	{
	467	pattLensTmp[i] = MAX_PATT_LEN;
	468	pattLenWarn = true;
	469	}
	470
	471	if (ph.dataLen > 0)
	472	{
	473	if (!allocateTmpPatt(i, pattLensTmp[i]))
	474	{
	475	loaderMsgBox("Not enough memory!");
	476	return false;
	477	}
	478
	479	if (fread(packedPattData, 1, ph.dataLen, f) != ph.dataLen)
	480	goto pattCorrupt;
	481
	482	unpackPatt((uint8_t *)pattTmp[i], packedPattData, pattLensTmp[i], songTmp.antChn);
	483	clearUnusedChannels(pattTmp[i], pattLensTmp[i], songTmp.antChn);
	484	}
	485
	486	if (tmpPatternEmpty(i))
	487	{
	488	if (pattTmp[i] != NULL)
	489	{
	490	free(pattTmp[i]);
	491	pattTmp[i] = NULL;
	492	}
	493
	494	pattLensTmp[i] = 64;
	495	}
	496	}
	497
	498	if (pattLenWarn)
	499	loaderMsgBox("This module contains pattern(s) with a length above 256! They will be truncated.");
	500
	501	return true;
	502
	503	pattCorrupt:
	504	loaderMsgBox("Error loading XM: This file is corrupt!");
	505	return false;
	506	}
	507
	508	static void unpackPatt(uint8_t dst, uint8_t src, uint16_t len, int32_t antChn)
	509	{
	510	int32_t j;
	511
	512	if (dst == NULL)
	513	return;
	514
	515	const int32_t srcEnd = len * (sizeof (tonTyp) * antChn);
	516	int32_t srcIdx = 0;
	517
	518	int32_t numChannels = antChn;
	519	if (numChannels > MAX_VOICES)
	520	numChannels = MAX_VOICES;
	521
	522	const int32_t pitch = sizeof (tonTyp) * (MAX_VOICES - antChn);
	523	for (int32_t i = 0; i < len; i++)
	524	{
	525	for (j = 0; j < numChannels; j++)
	526	{
	527	if (srcIdx >= srcEnd)
	528	return; // error!
	529
	530	const uint8_t note = *src++;
	531	if (note & 0x80)
	532	{
	533	dst++ = (note & 0x01) ? src++ : 0;
	534	dst++ = (note & 0x02) ? src++ : 0;
	535	dst++ = (note & 0x04) ? src++ : 0;
	536	dst++ = (note & 0x08) ? src++ : 0;
	537	dst++ = (note & 0x10) ? src++ : 0;
	538	}
	539	else
	540	{
	541	*dst++ = note;
	542	dst++ = src++;
	543	dst++ = src++;
	544	dst++ = src++;
	545	dst++ = src++;
	546	}
	547
	548	// if note is overflowing (>97), remove it
	549	if (*(dst-5) > 97)
	550	*(dst-5) = 0;
	551
	552	// non-FT2 security fix: if effect is above 35 (Z), clear effect and parameter
	553	if (*(dst-2) > 35)
	554	{
	555	*(dst-2) = 0;
	556	*(dst-1) = 0;
	557	}
	558
	559	srcIdx += sizeof (tonTyp);
	560	}
	561
	562	// if more than 32 channels, skip rest of the channels for this row
	563	for (; j < antChn; j++)
	564	{
	565	if (srcIdx >= srcEnd)
	566	return; // error!
	567
	568	const uint8_t note = *src++;
	569	if (note & 0x80)
	570	{
	571	if (note & 0x01) src++;
	572	if (note & 0x02) src++;
	573	if (note & 0x04) src++;
	574	if (note & 0x08) src++;
	575	if (note & 0x10) src++;
	576	}
	577	else
	578	{
	579	src++;
	580	src++;
	581	src++;
	582	src++;
	583	}
	584
	585	srcIdx += sizeof (tonTyp);
	586	}
	587
	588	// if song has <32 channels, align pointer to next row (skip unused channels)
	589	if (antChn < MAX_VOICES)
	590	dst += pitch;
	591	}
	592	}
	593
	594	static void sanitizeInstrument(instrTyp *ins) // FT2 doesn't do this, but we do!
	595	{
	596	ins->midiProgram = CLAMP(ins->midiProgram, 0, 127);
	597	ins->midiBend = CLAMP(ins->midiBend, 0, 36);
	598
	599	if (ins->midiChannel > 15) ins->midiChannel = 15;
	600	if (ins->vibDepth > 0x0F) ins->vibDepth = 0x0F;
	601	if (ins->vibRate > 0x3F) ins->vibRate = 0x3F;
	602	if (ins->vibTyp > 3) ins->vibTyp = 0;
	603
	604	for (int32_t i = 0; i < 96; i++)
	605	{
	606	if (ins->ta[i] >= MAX_SMP_PER_INST)
	607	ins->ta[i] = MAX_SMP_PER_INST-1;
	608	}
	609
	610	if (ins->envVPAnt > 12) ins->envVPAnt = 12;
	611	if (ins->envVRepS > 11) ins->envVRepS = 11;
	612	if (ins->envVRepE > 11) ins->envVRepE = 11;
	613	if (ins->envVSust > 11) ins->envVSust = 11;
	614	if (ins->envPPAnt > 12) ins->envPPAnt = 12;
	615	if (ins->envPRepS > 11) ins->envPRepS = 11;
	616	if (ins->envPRepE > 11) ins->envPRepE = 11;
	617	if (ins->envPSust > 11) ins->envPSust = 11;
	618
	619	for (int32_t i= 0; i < 12; i++)
	620	{
	621	if ((uint16_t)ins->envVP[i][0] > 32767) ins->envVP[i][0] = 32767;
	622	if ((uint16_t)ins->envPP[i][0] > 32767) ins->envPP[i][0] = 32767;
	623	if ((uint16_t)ins->envVP[i][1] > 64) ins->envVP[i][1] = 64;
	624	if ((uint16_t)ins->envPP[i][1] > 63) ins->envPP[i][1] = 63;
	625	}
	626	}

src/smploaders/ft2_load_aiff.c+510−0

@@ -0,0 +1,510 @@
	1	// Apple AIFF sample loader
	2
	3	#include <stdio.h>
	4	#include <stdint.h>
	5	#include <stdbool.h>
	6	#include "../ft2_header.h"
	7	#include "../ft2_audio.h"
	8	#include "../ft2_sample_ed.h"
	9	#include "../ft2_sysreqs.h"
	10	#include "../ft2_sample_loader.h"
	11
	12	static int32_t getAIFFRate(uint8_t *in);
	13	static bool aiffIsStereo(FILE *f); // only ran on files that are confirmed to be AIFFs
	14
	15	bool loadAIFF(FILE *f, uint32_t filesize)
	16	{
	17	char compType[4];
	18	int8_t *audioDataS8;
	19	uint8_t sampleRateBytes[10], *audioDataU8;
	20	int16_t audioDataS16, audioDataS16_2, smp16;
	21	uint16_t numChannels, bitDepth;
	22	int32_t smp32, *audioDataS32;
	23	uint32_t i, blockName, blockSize;
	24	uint32_t offset, len32;
	25
	26	fseek(f, 8, SEEK_SET);
	27	fread(compType, 1, 4, f);
	28	rewind(f);
	29	if (!memcmp(compType, "AIFC", 4))
	30	{
	31	loaderMsgBox("Error loading sample: This AIFF type (AIFC) is not supported!");
	32	return false;
	33	}
	34
	35	if (filesize < 12)
	36	{
	37	loaderMsgBox("Error loading sample: The sample is not supported or is invalid!");
	38	return false;
	39	}
	40
	41	uint32_t commPtr = 0, commLen = 0;
	42	uint32_t ssndPtr = 0, ssndLen = 0;
	43
	44	fseek(f, 12, SEEK_SET);
	45	while (!feof(f) && (uint32_t)ftell(f) < filesize-12)
	46	{
	47	fread(&blockName, 4, 1, f); if (feof(f)) break;
	48	fread(&blockSize, 4, 1, f); if (feof(f)) break;
	49
	50	blockName = SWAP32(blockName);
	51	blockSize = SWAP32(blockSize);
	52
	53	switch (blockName)
	54	{
	55	case 0x434F4D4D: // "COMM"
	56	{
	57	commPtr = ftell(f);
	58	commLen = blockSize;
	59	}
	60	break;
	61
	62	case 0x53534E44: // "SSND"
	63	{
	64	ssndPtr = ftell(f);
	65	ssndLen = blockSize;
	66	}
	67	break;
	68
	69	default: break;
	70	}
	71
	72	fseek(f, blockSize + (blockSize & 1), SEEK_CUR);
	73	}
	74
	75	if (commPtr == 0 \|\| commLen < 18 \|\| ssndPtr == 0)
	76	{
	77	loaderMsgBox("Error loading sample: The sample is not supported or is invalid!");
	78	return false;
	79	}
	80
	81	// kludge for strange AIFFs
	82	if (ssndLen == 0)
	83	ssndLen = filesize - ssndPtr;
	84
	85	if (ssndPtr+ssndLen > (uint32_t)filesize)
	86	ssndLen = filesize - ssndPtr;
	87
	88	fseek(f, commPtr, SEEK_SET);
	89	fread(&numChannels, 2, 1, f); numChannels = SWAP16(numChannels);
	90	fseek(f, 4, SEEK_CUR);
	91	fread(&bitDepth, 2, 1, f); bitDepth = SWAP16(bitDepth);
	92	fread(sampleRateBytes, 1, 10, f);
	93
	94	if (numChannels != 1 && numChannels != 2)
	95	{
	96	loaderMsgBox("Error loading sample: Unsupported amounts of channels!");
	97	return false;
	98	}
	99
	100	if (bitDepth != 8 && bitDepth != 16 && bitDepth != 24 && bitDepth != 32)
	101	{
	102	loaderMsgBox("Error loading sample: Unsupported bitdepth!");
	103	return false;
	104	}
	105
	106	// read compression type (if present)
	107	if (commLen > 18)
	108	{
	109	fread(&compType, 1, 4, f);
	110	if (memcmp(compType, "NONE", 4) != 0)
	111	{
	112	loaderMsgBox("Error loading sample: The sample is not supported or is invalid!");
	113	return false;
	114	}
	115	}
	116
	117	uint32_t sampleRate = getAIFFRate(sampleRateBytes);
	118
	119	// sample data chunk
	120
	121	fseek(f, ssndPtr, SEEK_SET);
	122
	123	fread(&offset, 4, 1, f);
	124	if (offset > 0)
	125	{
	126	loaderMsgBox("Error loading sample: The sample is not supported or is invalid!");
	127	return false;
	128	}
	129
	130	fseek(f, 4, SEEK_CUR);
	131
	132	ssndLen -= 8; // don't include offset and blockSize datas
	133
	134	uint32_t sampleLength = ssndLen;
	135	if (sampleLength > MAX_SAMPLE_LEN)
	136	sampleLength = MAX_SAMPLE_LEN;
	137
	138	int16_t stereoSampleLoadMode = -1;
	139	if (aiffIsStereo(f))
	140	stereoSampleLoadMode = loaderSysReq(5, "System request", "This is a stereo sample...");
	141
	142	// read sample data
	143
	144	if (bitDepth == 8)
	145	{
	146	// 8-BIT SIGNED PCM
	147
	148	if (!allocateTmpSmpData(&tmpSmp, sampleLength))
	149	{
	150	loaderMsgBox("Not enough memory!");
	151	return false;
	152	}
	153
	154	if (fread(tmpSmp.pek, sampleLength, 1, f) != 1)
	155	{
	156	loaderMsgBox("General I/O error during loading! Is the file in use?");
	157	return false;
	158	}
	159
	160	audioDataS8 = (int8_t *)tmpSmp.pek;
	161
	162	// stereo conversion
	163	if (numChannels == 2)
	164	{
	165	sampleLength /= 2;
	166
	167	switch (stereoSampleLoadMode)
	168	{
	169	case STEREO_SAMPLE_READ_LEFT:
	170	{
	171	for (i = 1; i < sampleLength; i++)
	172	audioDataS8[i] = audioDataS8[(i * 2) + 0];
	173	}
	174	break;
	175
	176	case STEREO_SAMPLE_READ_RIGHT:
	177	{
	178	len32 = sampleLength - 1;
	179	for (i = 0; i < len32; i++)
	180	audioDataS8[i] = audioDataS8[(i * 2) + 1];
	181
	182	audioDataS8[i] = 0;
	183	}
	184	break;
	185
	186	default:
	187	case STEREO_SAMPLE_CONVERT:
	188	{
	189	len32 = sampleLength - 1;
	190	for (i = 0; i < len32; i++)
	191	{
	192	smp16 = (audioDataS8[(i * 2) + 0] + audioDataS8[(i * 2) + 1]) >> 1;
	193	audioDataS8[i] = (int8_t)smp16;
	194	}
	195
	196	audioDataS8[i] = 0;
	197	}
	198	break;
	199	}
	200	}
	201	}
	202	else if (bitDepth == 16)
	203	{
	204	// 16-BIT SIGNED PCM
	205
	206	sampleLength /= 2;
	207	if (!allocateTmpSmpData(&tmpSmp, sampleLength*2))
	208	{
	209	loaderMsgBox("Not enough memory!");
	210	return false;
	211	}
	212
	213	if (fread(tmpSmp.pek, sampleLength, 2, f) != 2)
	214	{
	215	loaderMsgBox("General I/O error during loading! Is the file in use?");
	216	return false;
	217	}
	218
	219	// fix endianness
	220	audioDataS16 = (int16_t *)tmpSmp.pek;
	221	for (i = 0; i < sampleLength; i++)
	222	audioDataS16[i] = SWAP16(audioDataS16[i]);
	223
	224	// stereo conversion
	225	if (numChannels == 2)
	226	{
	227	sampleLength /= 2;
	228
	229	switch (stereoSampleLoadMode)
	230	{
	231	case STEREO_SAMPLE_READ_LEFT:
	232	{
	233	for (i = 1; i < sampleLength; i++)
	234	audioDataS16[i] = audioDataS16[(i * 2) + 0];
	235	}
	236	break;
	237
	238	case STEREO_SAMPLE_READ_RIGHT:
	239	{
	240	len32 = sampleLength - 1;
	241	for (i = 0; i < len32; i++)
	242	audioDataS16[i] = audioDataS16[(i * 2) + 1];
	243
	244	audioDataS16[i] = 0;
	245	}
	246	break;
	247
	248	default:
	249	case STEREO_SAMPLE_CONVERT:
	250	{
	251	len32 = sampleLength - 1;
	252	for (i = 0; i < len32; i++)
	253	{
	254	smp32 = (audioDataS16[(i * 2) + 0] + audioDataS16[(i * 2) + 1]) >> 1;
	255	audioDataS16[i] = (int16_t)smp32;
	256	}
	257
	258	audioDataS16[i] = 0;
	259	}
	260	break;
	261	}
	262	}
	263
	264	sampleLength *= 2;
	265	tmpSmp.typ \|= 16;
	266	}
	267	else if (bitDepth == 24)
	268	{
	269	// 24-BIT SIGNED PCM
	270
	271	sampleLength /= 3;
	272	if (!allocateTmpSmpData(&tmpSmp, (sampleLength * 4) * 2))
	273	{
	274	loaderMsgBox("Not enough memory!");
	275	return false;
	276	}
	277
	278	if (fread(&tmpSmp.pek[sampleLength], sampleLength, 3, f) != 3)
	279	{
	280	loaderMsgBox("General I/O error during loading! Is the file in use?");
	281	return false;
	282	}
	283
	284	audioDataS32 = (int32_t *)tmpSmp.pek;
	285
	286	// convert to 32-bit
	287	audioDataU8 = (uint8_t *)tmpSmp.pek + sampleLength;
	288	for (i = 0; i < sampleLength; i++)
	289	{
	290	audioDataS32[i] = (audioDataU8[0] << 24) \| (audioDataU8[1] << 16) \| (audioDataU8[2] << 8);
	291	audioDataU8 += 3;
	292	}
	293
	294	// stereo conversion
	295	if (numChannels == 2)
	296	{
	297	sampleLength /= 2;
	298
	299	switch (stereoSampleLoadMode)
	300	{
	301	case STEREO_SAMPLE_READ_LEFT:
	302	{
	303	for (i = 1; i < sampleLength; i++)
	304	audioDataS32[i] = audioDataS32[(i * 2) + 0];
	305	}
	306	break;
	307
	308	case STEREO_SAMPLE_READ_RIGHT:
	309	{
	310	len32 = sampleLength - 1;
	311	for (i = 0; i < len32; i++)
	312	audioDataS32[i] = audioDataS32[(i * 2) + 1];
	313
	314	audioDataS32[i] = 0;
	315	}
	316	break;
	317
	318	default:
	319	case STEREO_SAMPLE_CONVERT:
	320	{
	321	len32 = sampleLength - 1;
	322	for (i = 0; i < len32; i++)
	323	{
	324	int64_t smp64 = audioDataS32[(i * 2) + 0];
	325	smp64 += audioDataS32[(i * 2) + 1];
	326	smp64 >>= 1;
	327
	328	audioDataS32[i] = (int32_t)smp64;
	329	}
	330
	331	audioDataS32[i] = 0;
	332	}
	333	break;
	334	}
	335	}
	336
	337	normalizeSigned32Bit(audioDataS32, sampleLength);
	338
	339	// downscale to 16-bit (ultra fast method!)
	340
	341	audioDataS16 = (int16_t *)tmpSmp.pek;
	342	audioDataS16_2 = (int16_t *)tmpSmp.pek + 1; // yes, this is aligned to words
	343
	344	for (i = 0; i < sampleLength; i++, audioDataS16_2++)
	345	audioDataS16[i] = audioDataS16_2[i];
	346
	347	sampleLength *= 2;
	348	tmpSmp.typ \|= 16;
	349	}
	350	else if (bitDepth == 32)
	351	{
	352	// 32-BIT SIGNED PCM
	353
	354	sampleLength /= 4;
	355	if (!allocateTmpSmpData(&tmpSmp, sampleLength * 4))
	356	{
	357	loaderMsgBox("Not enough memory!");
	358	return false;
	359	}
	360
	361	if (fread(tmpSmp.pek, sampleLength, 4, f) != 4)
	362	{
	363	loaderMsgBox("General I/O error during loading! Is the file in use?");
	364	return false;
	365	}
	366
	367	// fix endianness
	368	audioDataS32 = (int32_t *)tmpSmp.pek;
	369	for (i = 0; i < sampleLength; i++)
	370	audioDataS32[i] = SWAP32(audioDataS32[i]);
	371
	372	// stereo conversion
	373	if (numChannels == 2)
	374	{
	375	sampleLength /= 2;
	376
	377	switch (stereoSampleLoadMode)
	378	{
	379	case STEREO_SAMPLE_READ_LEFT:
	380	{
	381	for (i = 1; i < sampleLength; i++)
	382	audioDataS32[i] = audioDataS32[(i * 2) + 0];
	383	}
	384	break;
	385
	386	case STEREO_SAMPLE_READ_RIGHT:
	387	{
	388	len32 = sampleLength - 1;
	389	for (i = 0; i < len32; i++)
	390	audioDataS32[i] = audioDataS32[(i * 2) + 1];
	391
	392	audioDataS32[i] = 0;
	393	}
	394	break;
	395
	396	default:
	397	case STEREO_SAMPLE_CONVERT:
	398	{
	399	len32 = sampleLength - 1;
	400	for (i = 0; i < len32; i++)
	401	{
	402	int64_t smp64 = audioDataS32[(i * 2) + 0];
	403	smp64 += audioDataS32[(i * 2) + 1];
	404	smp64 >>= 1;
	405
	406	audioDataS32[i] = (int32_t)smp64;
	407	}
	408
	409	audioDataS32[i] = 0;
	410	}
	411	break;
	412	}
	413	}
	414
	415	normalizeSigned32Bit(audioDataS32, sampleLength);
	416
	417	// downscale to 16-bit (ultra fast method!)
	418
	419	audioDataS16 = (int16_t *)tmpSmp.pek;
	420	audioDataS16_2 = (int16_t *)tmpSmp.pek + 1; // yes, this is aligned to words
	421
	422	for (i = 0; i < sampleLength; i++, audioDataS16_2++)
	423	audioDataS16[i] = audioDataS16_2[i];
	424
	425	sampleLength *= 2;
	426	tmpSmp.typ \|= 16;
	427	}
	428
	429	reallocateTmpSmpData(&tmpSmp, sampleLength); // readjust memory needed
	430
	431	tmpSmp.len = sampleLength;
	432	tmpSmp.vol = 64;
	433	tmpSmp.pan = 128;
	434
	435	tuneSample(&tmpSmp, sampleRate, audio.linearPeriodsFlag);
	436
	437	return true;
	438	}
	439
	440	static int32_t getAIFFRate(uint8_t *in)
	441	{
	442	int32_t exp = (int32_t)(((in[0] & 0x7F) << 8) \| in[1]);
	443	uint32_t lo = (in[2] << 24) \| (in[3] << 16) \| (in[4] << 8) \| in[5];
	444	uint32_t hi = (in[6] << 24) \| (in[7] << 16) \| (in[8] << 8) \| in[9];
	445
	446	if (exp == 0 && lo == 0 && hi == 0)
	447	return 0;
	448
	449	exp -= 16383;
	450
	451	double dOut = ldexp(lo, -31 + exp) + ldexp(hi, -63 + exp);
	452	return (int32_t)(dOut + 0.5); // rounded
	453	}
	454
	455	static bool aiffIsStereo(FILE *f) // only ran on files that are confirmed to be AIFFs
	456	{
	457	uint16_t numChannels;
	458	uint32_t chunkID, chunkSize;
	459
	460	uint32_t oldPos = ftell(f);
	461
	462	fseek(f, 0, SEEK_END);
	463	int32_t filesize = ftell(f);
	464
	465	if (filesize < 12)
	466	{
	467	fseek(f, oldPos, SEEK_SET);
	468	return false;
	469	}
	470
	471	fseek(f, 12, SEEK_SET);
	472
	473	uint32_t commPtr = 0;
	474	uint32_t commLen = 0;
	475
	476	int32_t bytesRead = 0;
	477	while (!feof(f) && bytesRead < filesize-12)
	478	{
	479	fread(&chunkID, 4, 1, f); chunkID = SWAP32(chunkID); if (feof(f)) break;
	480	fread(&chunkSize, 4, 1, f); chunkSize = SWAP32(chunkSize); if (feof(f)) break;
	481
	482	int32_t endOfChunk = (ftell(f) + chunkSize) + (chunkSize & 1);
	483	switch (chunkID)
	484	{
	485	case 0x434F4D4D: // "COMM"
	486	{
	487	commPtr = ftell(f);
	488	commLen = chunkSize;
	489	}
	490	break;
	491
	492	default: break;
	493	}
	494
	495	bytesRead += (chunkSize + (chunkSize & 1));
	496	fseek(f, endOfChunk, SEEK_SET);
	497	}
	498
	499	if (commPtr == 0 \|\| commLen < 2)
	500	{
	501	fseek(f, oldPos, SEEK_SET);
	502	return false;
	503	}
	504
	505	fseek(f, commPtr, SEEK_SET);
	506	fread(&numChannels, 2, 1, f); numChannels = SWAP16(numChannels);
	507	fseek(f, oldPos, SEEK_SET);
	508
	509	return (numChannels == 2);
	510	}

src/smploaders/ft2_load_iff.c+179−0

@@ -0,0 +1,179 @@
	1	// IFF (Amiga/FT2) sample loader
	2
	3	#include <stdio.h>
	4	#include <stdint.h>
	5	#include <stdbool.h>
	6	#include "../ft2_header.h"
	7	#include "../ft2_audio.h"
	8	#include "../ft2_sample_ed.h"
	9	#include "../ft2_sysreqs.h"
	10	#include "../ft2_sample_loader.h"
	11
	12	bool loadIFF(FILE *f, uint32_t filesize)
	13	{
	14	char hdr[4+1];
	15	uint32_t sampleLength, sampleVol, sampleLoopStart, sampleLoopLength, sampleRate;
	16
	17	if (filesize < 12)
	18	{
	19	loaderMsgBox("Error loading sample: The sample is not supported or is invalid!");
	20	return false;
	21	}
	22
	23	fseek(f, 8, SEEK_SET);
	24	fread(hdr, 1, 4, f);
	25	hdr[4] = '\0';
	26	bool is16Bit = !strncmp(hdr, "16SV", 4);
	27
	28	uint32_t vhdrPtr = 0, vhdrLen = 0;
	29	uint32_t bodyPtr = 0, bodyLen = 0;
	30	uint32_t namePtr = 0, nameLen = 0;
	31
	32	fseek(f, 12, SEEK_SET);
	33	while (!feof(f) && (uint32_t)ftell(f) < filesize-12)
	34	{
	35	uint32_t blockName, blockSize;
	36	fread(&blockName, 4, 1, f); if (feof(f)) break;
	37	fread(&blockSize, 4, 1, f); if (feof(f)) break;
	38
	39	blockName = SWAP32(blockName);
	40	blockSize = SWAP32(blockSize);
	41
	42	switch (blockName)
	43	{
	44	case 0x56484452: // VHDR
	45	{
	46	vhdrPtr = ftell(f);
	47	vhdrLen = blockSize;
	48	}
	49	break;
	50
	51	case 0x4E414D45: // NAME
	52	{
	53	namePtr = ftell(f);
	54	nameLen = blockSize;
	55	}
	56	break;
	57
	58	case 0x424F4459: // BODY
	59	{
	60	bodyPtr = ftell(f);
	61	bodyLen = blockSize;
	62	}
	63	break;
	64
	65	default: break;
	66	}
	67
	68	fseek(f, blockSize + (blockSize & 1), SEEK_CUR);
	69	}
	70
	71	if (vhdrPtr == 0 \|\| vhdrLen < 20 \|\| bodyPtr == 0)
	72	{
	73	loaderMsgBox("Error loading sample: The sample is not supported or is invalid!");
	74	return false;
	75	}
	76
	77	// kludge for some really strange IFFs
	78	if (bodyLen == 0)
	79	bodyLen = filesize - bodyPtr;
	80
	81	if (bodyPtr+bodyLen > (uint32_t)filesize)
	82	bodyLen = filesize - bodyPtr;
	83
	84	fseek(f, vhdrPtr, SEEK_SET);
	85	fread(&sampleLoopStart, 4, 1, f); sampleLoopStart = SWAP32(sampleLoopStart);
	86	fread(&sampleLoopLength, 4, 1, f); sampleLoopLength = SWAP32(sampleLoopLength);
	87	fseek(f, 4, SEEK_CUR);
	88	fread(&sampleRate, 2, 1, f); sampleRate = SWAP16(sampleRate);
	89	fseek(f, 1, SEEK_CUR);
	90
	91	if (fgetc(f) != 0) // sample type
	92	{
	93	loaderMsgBox("Error loading sample: The sample is not supported!");
	94	return false;
	95	}
	96
	97	fread(&sampleVol, 4, 1, f); sampleVol = SWAP32(sampleVol);
	98	if (sampleVol > 65535)
	99	sampleVol = 65535;
	100
	101	sampleVol = (sampleVol + 512) / 1024; // rounded
	102
	103	sampleLength = bodyLen;
	104	if (sampleLength > MAX_SAMPLE_LEN)
	105	sampleLength = MAX_SAMPLE_LEN;
	106
	107	if (sampleLoopStart >= MAX_SAMPLE_LEN \|\| sampleLoopLength > MAX_SAMPLE_LEN)
	108	{
	109	sampleLoopStart = 0;
	110	sampleLoopLength = 0;
	111	}
	112
	113	if (sampleLoopStart+sampleLoopLength > sampleLength)
	114	{
	115	sampleLoopStart = 0;
	116	sampleLoopLength = 0;
	117	}
	118
	119	if (sampleLoopStart > sampleLength-2)
	120	{
	121	sampleLoopStart = 0;
	122	sampleLoopLength = 0;
	123	}
	124
	125	if (!allocateTmpSmpData(&tmpSmp, sampleLength))
	126	{
	127	loaderMsgBox("Not enough memory!");
	128	return false;
	129	}
	130
	131	fseek(f, bodyPtr, SEEK_SET);
	132	if (fread(tmpSmp.pek, sampleLength, 1, f) != 1)
	133	{
	134	loaderMsgBox("General I/O error during loading! Is the file in use?");
	135	return false;
	136	}
	137
	138	tmpSmp.len = sampleLength;
	139
	140	if (sampleLoopLength > 2)
	141	{
	142	tmpSmp.repS = sampleLoopStart;
	143	tmpSmp.repL = sampleLoopLength;
	144	tmpSmp.typ \|= 1;
	145	}
	146
	147	if (is16Bit)
	148	{
	149	tmpSmp.len &= 0xFFFFFFFE;
	150	tmpSmp.repS &= 0xFFFFFFFE;
	151	tmpSmp.repL &= 0xFFFFFFFE;
	152	tmpSmp.typ \|= 16;
	153	}
	154
	155	tmpSmp.vol = (uint8_t)sampleVol;
	156	tmpSmp.pan = 128;
	157
	158	tuneSample(&tmpSmp, sampleRate, audio.linearPeriodsFlag);
	159
	160	// set name
	161	if (namePtr != 0 && nameLen > 0)
	162	{
	163	fseek(f, namePtr, SEEK_SET);
	164	if (nameLen > 21)
	165	{
	166	fread(tmpSmp.name, 1, 21, f);
	167	tmpSmp.name[21] = '\0';
	168	}
	169	else
	170	{
	171	memset(tmpSmp.name, 0, 22);
	172	fread(tmpSmp.name, 1, nameLen, f);
	173	}
	174
	175	smpFilenameSet = true;
	176	}
	177
	178	return true;
	179	}

src/smploaders/ft2_load_raw.c+30−0

@@ -0,0 +1,30 @@
	1	// RAW (header-less) sample loader
	2
	3	#include <stdio.h>
	4	#include <stdint.h>
	5	#include <stdbool.h>
	6	#include "../ft2_header.h"
	7	#include "../ft2_sample_ed.h"
	8	#include "../ft2_sysreqs.h"
	9	#include "../ft2_sample_loader.h"
	10
	11	bool loadRAW(FILE *f, uint32_t filesize)
	12	{
	13	if (!allocateTmpSmpData(&tmpSmp, filesize))
	14	{
	15	loaderMsgBox("Not enough memory!");
	16	return false;
	17	}
	18
	19	if (fread(tmpSmp.pek, filesize, 1, f) != 1)
	20	{
	21	okBoxThreadSafe(0, "System message", "General I/O error during loading! Is the file in use?");
	22	return false;
	23	}
	24
	25	tmpSmp.len = filesize;
	26	tmpSmp.vol = 64;
	27	tmpSmp.pan = 128;
	28
	29	return true;
	30	}

src/smploaders/ft2_load_wav.c+746−0

@@ -0,0 +1,746 @@
	1	// WAV sample loader
	2
	3	#include <stdio.h>
	4	#include <stdint.h>
	5	#include <stdbool.h>
	6	#include "../ft2_header.h"
	7	#include "../ft2_audio.h"
	8	#include "../ft2_sample_ed.h"
	9	#include "../ft2_sysreqs.h"
	10	#include "../ft2_sample_loader.h"
	11
	12	enum
	13	{
	14	WAV_FORMAT_PCM = 1,
	15	WAV_FORMAT_IEEE_FLOAT = 3
	16	};
	17
	18	static bool wavIsStereo(FILE *f);
	19
	20	bool loadWAV(FILE *f, uint32_t filesize)
	21	{
	22	uint8_t *audioDataU8;
	23	int16_t audioDataS16, audioDataS16_2, *ptr16;
	24	uint16_t audioFormat, numChannels, bitsPerSample;
	25	int32_t *audioDataS32;
	26	uint32_t i, sampleRate, sampleLength;
	27	uint32_t len32;
	28	float *fAudioDataFloat;
	29	double *dAudioDataDouble;
	30
	31	if (filesize < 12)
	32	{
	33	loaderMsgBox("Error loading sample: The sample is not supported or is invalid!");
	34	return false;
	35	}
	36
	37	uint32_t fmtPtr = 0, fmtLen = 0;
	38	uint32_t dataPtr = 0, dataLen = 0;
	39	uint32_t inamPtr = 0, inamLen = 0;
	40	uint32_t xtraPtr = 0, xtraLen = 0;
	41	uint32_t smplPtr = 0, smplLen = 0;
	42
	43	// look for wanted chunks and set up pointers + lengths
	44	fseek(f, 12, SEEK_SET);
	45
	46	uint32_t bytesRead = 0;
	47	while (!feof(f) && bytesRead < filesize-12)
	48	{
	49	uint32_t chunkID, chunkSize;
	50	fread(&chunkID, 4, 1, f); if (feof(f)) break;
	51	fread(&chunkSize, 4, 1, f); if (feof(f)) break;
	52
	53	uint32_t endOfChunk = (ftell(f) + chunkSize) + (chunkSize & 1);
	54	switch (chunkID)
	55	{
	56	case 0x20746D66: // "fmt "
	57	{
	58	fmtPtr = ftell(f);
	59	fmtLen = chunkSize;
	60	}
	61	break;
	62
	63	case 0x61746164: // "data"
	64	{
	65	dataPtr = ftell(f);
	66	dataLen = chunkSize;
	67	}
	68	break;
	69
	70	case 0x5453494C: // "LIST"
	71	{
	72	if (chunkSize >= 4)
	73	{
	74	fread(&chunkID, 4, 1, f);
	75	if (chunkID == 0x4F464E49) // "INFO"
	76	{
	77	bytesRead = 0;
	78	while (!feof(f) && bytesRead < chunkSize)
	79	{
	80	fread(&chunkID, 4, 1, f);
	81	fread(&chunkSize, 4, 1, f);
	82
	83	switch (chunkID)
	84	{
	85	case 0x4D414E49: // "INAM"
	86	{
	87	inamPtr = ftell(f);
	88	inamLen = chunkSize;
	89	}
	90	break;
	91
	92	default: break;
	93	}
	94
	95	bytesRead += (chunkSize + (chunkSize & 1));
	96	}
	97	}
	98	}
	99	}
	100	break;
	101
	102	case 0x61727478: // "xtra"
	103	{
	104	xtraPtr = ftell(f);
	105	xtraLen = chunkSize;
	106	}
	107	break;
	108
	109	case 0x6C706D73: // "smpl"
	110	{
	111	smplPtr = ftell(f);
	112	smplLen = chunkSize;
	113	}
	114	break;
	115
	116	default: break;
	117	}
	118
	119	bytesRead += (chunkSize + (chunkSize & 1));
	120	fseek(f, endOfChunk, SEEK_SET);
	121	}
	122
	123	// we need at least "fmt " and "data" - check if we found them sanely
	124	if (fmtPtr == 0 \|\| fmtLen < 16 \|\| dataPtr == 0 \|\| dataLen == 0)
	125	{
	126	loaderMsgBox("Error loading sample: The sample is not supported or is invalid!");
	127	return false;
	128	}
	129
	130	// ---- READ "fmt " CHUNK ----
	131	fseek(f, fmtPtr, SEEK_SET);
	132	fread(&audioFormat, 2, 1, f);
	133	fread(&numChannels, 2, 1, f);
	134	fread(&sampleRate, 4, 1, f);
	135	fseek(f, 6, SEEK_CUR); // unneeded
	136	fread(&bitsPerSample, 2, 1, f);
	137	sampleLength = dataLen;
	138	// ---------------------------
	139
	140	// test if the WAV is compatible with our loader
	141
	142	if (sampleRate == 0 \|\| sampleLength == 0 \|\| sampleLength >= filesize)
	143	{
	144	loaderMsgBox("Error loading sample: The sample is not supported or is invalid!");
	145	return false;
	146	}
	147
	148	if (audioFormat != WAV_FORMAT_PCM && audioFormat != WAV_FORMAT_IEEE_FLOAT)
	149	{
	150	loaderMsgBox("Error loading sample: The sample is not supported!");
	151	return false;
	152	}
	153
	154	if (numChannels == 0 \|\| numChannels > 2)
	155	{
	156	loaderMsgBox("Error loading sample: Unsupported number of channels!");
	157	return false;
	158	}
	159
	160	if (audioFormat == WAV_FORMAT_IEEE_FLOAT && bitsPerSample != 32 && bitsPerSample != 64)
	161	{
	162	loaderMsgBox("Error loading sample: Unsupported bitdepth!");
	163	return false;
	164	}
	165
	166	if (bitsPerSample != 8 && bitsPerSample != 16 && bitsPerSample != 24 && bitsPerSample != 32 && bitsPerSample != 64)
	167	{
	168	loaderMsgBox("Error loading sample: Unsupported bitdepth!");
	169	return false;
	170	}
	171
	172	// ---- READ SAMPLE DATA ----
	173	fseek(f, dataPtr, SEEK_SET);
	174
	175	if (sampleLength > MAX_SAMPLE_LEN)
	176	sampleLength = MAX_SAMPLE_LEN;
	177
	178	int16_t stereoSampleLoadMode = -1;
	179	if (wavIsStereo(f))
	180	stereoSampleLoadMode = loaderSysReq(5, "System request", "This is a stereo sample...");
	181
	182	if (bitsPerSample == 8) // 8-BIT INTEGER SAMPLE
	183	{
	184	if (!allocateTmpSmpData(&tmpSmp, sampleLength))
	185	{
	186	loaderMsgBox("Not enough memory!");
	187	return false;
	188	}
	189
	190	if (fread(tmpSmp.pek, sampleLength, 1, f) != 1)
	191	{
	192	loaderMsgBox("General I/O error during loading! Is the file in use?");
	193	return false;
	194	}
	195
	196	audioDataU8 = (uint8_t *)tmpSmp.pek;
	197
	198	// stereo conversion
	199	if (numChannels == 2)
	200	{
	201	sampleLength /= 2;
	202	switch (stereoSampleLoadMode)
	203	{
	204	case STEREO_SAMPLE_READ_LEFT:
	205	{
	206	// remove right channel data
	207	for (i = 1; i < sampleLength; i++)
	208	audioDataU8[i] = audioDataU8[(i * 2) + 0];
	209	}
	210	break;
	211
	212	case STEREO_SAMPLE_READ_RIGHT:
	213	{
	214	// remove left channel data
	215	len32 = sampleLength - 1;
	216	for (i = 0; i < len32; i++)
	217	audioDataU8[i] = audioDataU8[(i * 2) + 1];
	218
	219	audioDataU8[i] = 128;
	220	}
	221	break;
	222
	223	default:
	224	case STEREO_SAMPLE_CONVERT:
	225	{
	226	// mix stereo to mono
	227	len32 = sampleLength - 1;
	228	for (i = 0; i < len32; i++)
	229	audioDataU8[i] = (audioDataU8[(i * 2) + 0] + audioDataU8[(i * 2) + 1]) >> 1;
	230
	231	audioDataU8[i] = 128;
	232	}
	233	break;
	234	}
	235	}
	236
	237	// convert from unsigned to signed
	238	for (i = 0; i < sampleLength; i++)
	239	tmpSmp.pek[i] ^= 0x80;
	240	}
	241	else if (bitsPerSample == 16) // 16-BIT INTEGER SAMPLE
	242	{
	243	sampleLength /= 2;
	244	if (!allocateTmpSmpData(&tmpSmp, sampleLength*2))
	245	{
	246	loaderMsgBox("Not enough memory!");
	247	return false;
	248	}
	249
	250	if (fread(tmpSmp.pek, sampleLength, 2, f) != 2)
	251	{
	252	loaderMsgBox("General I/O error during loading! Is the file in use?");
	253	return false;
	254	}
	255
	256	audioDataS16 = (int16_t *)tmpSmp.pek;
	257
	258	// stereo conversion
	259	if (numChannels == 2)
	260	{
	261	sampleLength /= 2;
	262
	263	switch (stereoSampleLoadMode)
	264	{
	265	case STEREO_SAMPLE_READ_LEFT:
	266	{
	267	// remove right channel data
	268	for (i = 1; i < sampleLength; i++)
	269	audioDataS16[i] = audioDataS16[(i * 2) + 0];
	270	}
	271	break;
	272
	273	case STEREO_SAMPLE_READ_RIGHT:
	274	{
	275	// remove left channel data
	276	len32 = sampleLength - 1;
	277	for (i = 0; i < len32; i++)
	278	audioDataS16[i] = audioDataS16[(i * 2) + 1];
	279
	280	audioDataS16[i] = 0;
	281	}
	282	break;
	283
	284	default:
	285	case STEREO_SAMPLE_CONVERT:
	286	{
	287	// mix stereo to mono
	288	len32 = sampleLength - 1;
	289	for (i = 0; i < len32; i++)
	290	{
	291	int32_t smp32 = audioDataS16[(i * 2) + 0] + audioDataS16[(i * 2) + 1];
	292	audioDataS16[i] = (int16_t)(smp32 >> 1);
	293	}
	294
	295	audioDataS16[i] = 0;
	296	}
	297	break;
	298	}
	299	}
	300
	301	sampleLength *= 2;
	302	tmpSmp.typ \|= 16; // 16-bit
	303	}
	304	else if (bitsPerSample == 24) // 24-BIT INTEGER SAMPLE
	305	{
	306	sampleLength /= 3;
	307	if (!allocateTmpSmpData(&tmpSmp, (sampleLength * 4) * 2))
	308	{
	309	loaderMsgBox("Not enough memory!");
	310	return false;
	311	}
	312
	313	if (fread(&tmpSmp.pek[sampleLength], sampleLength, 3, f) != 3)
	314	{
	315	loaderMsgBox("General I/O error during loading! Is the file in use?");
	316	return false;
	317	}
	318
	319	audioDataS32 = (int32_t *)tmpSmp.pek;
	320
	321	// convert to 32-bit
	322	audioDataU8 = (uint8_t *)tmpSmp.pek + sampleLength;
	323	for (i = 0; i < sampleLength; i++)
	324	{
	325	audioDataS32[i] = (audioDataU8[2] << 24) \| (audioDataU8[1] << 16) \| (audioDataU8[0] << 8);
	326	audioDataU8 += 3;
	327	}
	328
	329	// stereo conversion
	330	if (numChannels == 2)
	331	{
	332	sampleLength /= 2;
	333	switch (stereoSampleLoadMode)
	334	{
	335	case STEREO_SAMPLE_READ_LEFT:
	336	{
	337	// remove right channel data
	338	for (i = 1; i < sampleLength; i++)
	339	audioDataS32[i] = audioDataS32[(i * 2) + 0];
	340	}
	341	break;
	342
	343	case STEREO_SAMPLE_READ_RIGHT:
	344	{
	345	// remove left channel data
	346	len32 = sampleLength - 1;
	347	for (i = 0; i < len32; i++)
	348	audioDataS32[i] = audioDataS32[(i * 2) + 1];
	349
	350	audioDataS32[i] = 0;
	351	}
	352	break;
	353
	354	default:
	355	case STEREO_SAMPLE_CONVERT:
	356	{
	357	// mix stereo to mono
	358	len32 = sampleLength - 1;
	359	for (i = 0; i < len32; i++)
	360	{
	361	int64_t smp64 = audioDataS32[(i * 2) + 0];
	362	smp64 += audioDataS32[(i * 2) + 1];
	363	smp64 >>= 1;
	364
	365	audioDataS32[i] = (int32_t)smp64;
	366	}
	367
	368	audioDataS32[i] = 0;
	369	}
	370	break;
	371	}
	372	}
	373
	374	normalizeSigned32Bit(audioDataS32, sampleLength);
	375
	376	// downscale to 16-bit (ultra fast method!)
	377
	378	audioDataS16 = (int16_t *)tmpSmp.pek;
	379	audioDataS16_2 = (int16_t *)tmpSmp.pek + 1; // yes, this is aligned to words
	380
	381	for (i = 0; i < sampleLength; i++, audioDataS16_2++)
	382	audioDataS16[i] = audioDataS16_2[i];
	383
	384	sampleLength *= 2;
	385	tmpSmp.typ \|= 16; // 16-bit
	386	}
	387	else if (audioFormat == WAV_FORMAT_PCM && bitsPerSample == 32) // 32-BIT INTEGER SAMPLE
	388	{
	389	sampleLength /= 4;
	390	if (!allocateTmpSmpData(&tmpSmp, sampleLength * 4))
	391	{
	392	loaderMsgBox("Not enough memory!");
	393	return false;
	394	}
	395
	396	if (fread(tmpSmp.pek, sampleLength, 4, f) != 4)
	397	{
	398	loaderMsgBox("General I/O error during loading! Is the file in use?");
	399	return false;
	400	}
	401
	402	audioDataS32 = (int32_t *)tmpSmp.pek;
	403
	404	// stereo conversion
	405	if (numChannels == 2)
	406	{
	407	sampleLength /= 2;
	408	switch (stereoSampleLoadMode)
	409	{
	410	case STEREO_SAMPLE_READ_LEFT:
	411	{
	412	// remove right channel data
	413	for (i = 1; i < sampleLength; i++)
	414	audioDataS32[i] = audioDataS32[(i * 2) + 0];
	415	}
	416	break;
	417
	418	case STEREO_SAMPLE_READ_RIGHT:
	419	{
	420	// remove left channel data
	421	len32 = sampleLength - 1;
	422	for (i = 0; i < len32; i++)
	423	audioDataS32[i] = audioDataS32[(i * 2) + 1];
	424
	425	audioDataS32[i] = 0;
	426	}
	427	break;
	428
	429	default:
	430	case STEREO_SAMPLE_CONVERT:
	431	{
	432	// mix stereo to mono
	433	len32 = sampleLength - 1;
	434	for (i = 0; i < len32; i++)
	435	{
	436	int64_t smp64 = audioDataS32[(i * 2) + 0];
	437	smp64 += audioDataS32[(i * 2) + 1];
	438	smp64 >>= 1;
	439
	440	audioDataS32[i] = (int32_t)smp64;
	441	}
	442
	443	audioDataS32[i] = 0;
	444	}
	445	break;
	446	}
	447	}
	448
	449	normalizeSigned32Bit(audioDataS32, sampleLength);
	450
	451	// downscale to 16-bit (ultra fast method!)
	452
	453	audioDataS16 = (int16_t *)tmpSmp.pek;
	454	audioDataS16_2 = (int16_t *)tmpSmp.pek + 1; // yes, this is aligned to words
	455
	456	for (i = 0; i < sampleLength; i++, audioDataS16_2++)
	457	audioDataS16[i] = audioDataS16_2[i];
	458
	459	sampleLength *= 2;
	460	tmpSmp.typ \|= 16; // 16-bit
	461	}
	462	else if (audioFormat == WAV_FORMAT_IEEE_FLOAT && bitsPerSample == 32) // 32-BIT FLOATING POINT SAMPLE
	463	{
	464	sampleLength /= 4;
	465	if (!allocateTmpSmpData(&tmpSmp, sampleLength * 4))
	466	{
	467	loaderMsgBox("Not enough memory!");
	468	return false;
	469	}
	470
	471	if (fread(tmpSmp.pek, sampleLength, 4, f) != 4)
	472	{
	473	loaderMsgBox("General I/O error during loading! Is the file in use?");
	474	return false;
	475	}
	476
	477	fAudioDataFloat = (float *)tmpSmp.pek;
	478
	479	// stereo conversion
	480	if (numChannels == 2)
	481	{
	482	sampleLength /= 2;
	483	switch (stereoSampleLoadMode)
	484	{
	485	case STEREO_SAMPLE_READ_LEFT:
	486	{
	487	// remove right channel data
	488	for (i = 1; i < sampleLength; i++)
	489	fAudioDataFloat[i] = fAudioDataFloat[(i * 2) + 0];
	490	}
	491	break;
	492
	493	case STEREO_SAMPLE_READ_RIGHT:
	494	{
	495	// remove left channel data
	496	len32 = sampleLength - 1;
	497	for (i = 0; i < len32; i++)
	498	fAudioDataFloat[i] = fAudioDataFloat[(i * 2) + 1];
	499
	500	fAudioDataFloat[i] = 0.0f;
	501	}
	502	break;
	503
	504	default:
	505	case STEREO_SAMPLE_CONVERT:
	506	{
	507	// mix stereo to mono
	508	len32 = sampleLength - 1;
	509	for (i = 0; i < len32; i++)
	510	fAudioDataFloat[i] = (fAudioDataFloat[(i * 2) + 0] + fAudioDataFloat[(i * 2) + 1]) * 0.5f;
	511
	512	fAudioDataFloat[i] = 0.0f;
	513	}
	514	break;
	515	}
	516	}
	517
	518	normalize32BitFloatToSigned16Bit(fAudioDataFloat, sampleLength);
	519
	520	ptr16 = (int16_t *)tmpSmp.pek;
	521	for (i = 0; i < sampleLength; i++)
	522	ptr16[i] = (int16_t)fAudioDataFloat[i]; // should use SIMD if available
	523
	524	sampleLength *= 2;
	525	tmpSmp.typ \|= 16; // 16-bit
	526	}
	527	else if (audioFormat == WAV_FORMAT_IEEE_FLOAT && bitsPerSample == 64) // 64-BIT FLOATING POINT SAMPLE
	528	{
	529	sampleLength /= 8;
	530	if (!allocateTmpSmpData(&tmpSmp, sampleLength * 8))
	531	{
	532	loaderMsgBox("Not enough memory!");
	533	return false;
	534	}
	535
	536	if (fread(tmpSmp.pek, sampleLength, 8, f) != 8)
	537	{
	538	loaderMsgBox("General I/O error during loading! Is the file in use?");
	539	return false;
	540	}
	541
	542	dAudioDataDouble = (double *)tmpSmp.pek;
	543
	544	// stereo conversion
	545	if (numChannels == 2)
	546	{
	547	sampleLength /= 2;
	548	switch (stereoSampleLoadMode)
	549	{
	550	case STEREO_SAMPLE_READ_LEFT:
	551	{
	552	// remove right channel data
	553	for (i = 1; i < sampleLength; i++)
	554	dAudioDataDouble[i] = dAudioDataDouble[(i * 2) + 0];
	555	}
	556	break;
	557
	558	case STEREO_SAMPLE_READ_RIGHT:
	559	{
	560	// remove left channel data
	561	len32 = sampleLength - 1;
	562	for (i = 0; i < len32; i++)
	563	dAudioDataDouble[i] = dAudioDataDouble[(i * 2) + 1];
	564
	565	dAudioDataDouble[i] = 0.0;
	566	}
	567	break;
	568
	569	default:
	570	case STEREO_SAMPLE_CONVERT:
	571	{
	572	// mix stereo to mono
	573	len32 = sampleLength - 1;
	574	for (i = 0; i < len32; i++)
	575	dAudioDataDouble[i] = (dAudioDataDouble[(i * 2) + 0] + dAudioDataDouble[(i * 2) + 1]) * 0.5;
	576
	577	dAudioDataDouble[i] = 0.0;
	578	}
	579	break;
	580	}
	581	}
	582
	583	normalize64BitFloatToSigned16Bit(dAudioDataDouble, sampleLength);
	584
	585	ptr16 = (int16_t *)tmpSmp.pek;
	586	for (i = 0; i < sampleLength; i++)
	587	ptr16[i] = (int16_t)dAudioDataDouble[i]; // should use SIMD if available
	588
	589	sampleLength *= 2;
	590	tmpSmp.typ \|= 16; // 16-bit
	591	}
	592
	593	reallocateTmpSmpData(&tmpSmp, sampleLength); // readjust memory needed
	594
	595	tuneSample(&tmpSmp, sampleRate, audio.linearPeriodsFlag);
	596
	597	tmpSmp.vol = 64;
	598	tmpSmp.pan = 128;
	599	tmpSmp.len = sampleLength;
	600
	601	// ---- READ "smpl" chunk ----
	602	if (smplPtr != 0 && smplLen > 52)
	603	{
	604	uint32_t numLoops, loopType, loopStart, loopEnd;
	605
	606	fseek(f, smplPtr+28, SEEK_SET); // seek to first wanted byte
	607
	608	fread(&numLoops, 4, 1, f);
	609	if (numLoops == 1)
	610	{
	611	fseek(f, 4+4, SEEK_CUR); // skip "samplerData" and "identifier"
	612
	613	fread(&loopType, 4, 1, f);
	614	fread(&loopStart, 4, 1, f);
	615	fread(&loopEnd, 4, 1, f); loopEnd++;
	616
	617	if (tmpSmp.typ & 16)
	618	{
	619	loopStart *= 2;
	620	loopEnd *= 2;
	621	}
	622
	623	if (loopEnd <= sampleLength)
	624	{
	625	tmpSmp.repS = loopStart;
	626	tmpSmp.repL = loopEnd - loopStart;
	627	tmpSmp.typ \|= (loopType == 0) ? 1 : 2;
	628	}
	629	}
	630	}
	631	// ---------------------------
	632
	633	// ---- READ "xtra" chunk ----
	634	if (xtraPtr != 0 && xtraLen >= 8)
	635	{
	636	uint16_t tmpPan, tmpVol;
	637	uint32_t xtraFlags;
	638
	639	fseek(f, xtraPtr, SEEK_SET);
	640	fread(&xtraFlags, 4, 1, f); // flags
	641
	642	// panning (0..256)
	643	if (xtraFlags & 0x20) // set panning flag
	644	{
	645	fread(&tmpPan, 2, 1, f);
	646	if (tmpPan > 255)
	647	tmpPan = 255;
	648
	649	tmpSmp.pan = (uint8_t)tmpPan;
	650	}
	651	else
	652	{
	653	// don't read panning, skip it
	654	fseek(f, 2, SEEK_CUR);
	655	}
	656
	657	// volume (0..256)
	658	fread(&tmpVol, 2, 1, f);
	659	if (tmpVol > 256)
	660	tmpVol = 256;
	661
	662	tmpSmp.vol = (uint8_t)((tmpVol + 2) / 4); // 0..256 -> 0..64 (rounded)
	663	}
	664	// ---------------------------
	665
	666	// ---- READ "INAM" chunk ----
	667	if (inamPtr != 0 && inamLen > 0)
	668	{
	669	fseek(f, inamPtr, SEEK_SET);
	670
	671	uint32_t len = 22;
	672	if (len > inamLen)
	673	len = inamLen;
	674
	675	memset(tmpSmp.name, 0, sizeof (tmpSmp.name));
	676	for (i = 0; i < len; i++)
	677	{
	678	char chr = (char)fgetc(f);
	679	if (chr == '\0')
	680	break;
	681
	682	tmpSmp.name[i] = chr;
	683	}
	684
	685	smpFilenameSet = true;
	686	}
	687
	688	return true;
	689	}
	690
	691	static bool wavIsStereo(FILE *f)
	692	{
	693	uint16_t numChannels;
	694	uint32_t chunkID, chunkSize;
	695
	696	uint32_t oldPos = ftell(f);
	697
	698	fseek(f, 0, SEEK_END);
	699	int32_t filesize = ftell(f);
	700
	701	if (filesize < 12)
	702	{
	703	fseek(f, oldPos, SEEK_SET);
	704	return false;
	705	}
	706
	707	fseek(f, 12, SEEK_SET);
	708
	709	uint32_t fmtPtr = 0;
	710	uint32_t fmtLen = 0;
	711
	712	int32_t bytesRead = 0;
	713	while (!feof(f) && bytesRead < filesize-12)
	714	{
	715	fread(&chunkID, 4, 1, f); if (feof(f)) break;
	716	fread(&chunkSize, 4, 1, f); if (feof(f)) break;
	717
	718	int32_t endOfChunk = (ftell(f) + chunkSize) + (chunkSize & 1);
	719	switch (chunkID)
	720	{
	721	case 0x20746D66: // "fmt "
	722	{
	723	fmtPtr = ftell(f);
	724	fmtLen = chunkSize;
	725	}
	726	break;
	727
	728	default: break;
	729	}
	730
	731	bytesRead += (chunkSize + (chunkSize & 1));
	732	fseek(f, endOfChunk, SEEK_SET);
	733	}
	734
	735	if (fmtPtr == 0 \|\| fmtLen < 4)
	736	{
	737	fseek(f, oldPos, SEEK_SET);
	738	return false;
	739	}
	740
	741	fseek(f, fmtPtr + 2, SEEK_SET);
	742	fread(&numChannels, 2, 1, f);
	743
	744	fseek(f, oldPos, SEEK_SET);
	745	return (numChannels == 2);
	746	}

Big code change, read description

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code