assets/mbbrailtextures/advtrains_dtrack_rail.png

/*
   Basic Unicode string class for Irrlicht.
   Copyright (c) 2009-2011 John Norman

   This software is provided 'as-is', without any express or implied
   warranty. In no event will the authors be held liable for any
   damages arising from the use of this software.

   Permission is granted to anyone to use this software for any
   purpose, including commercial applications, and to alter it and
   redistribute it freely, subject to the following restrictions:

   1. The origin of this software must not be misrepresented; you
      must not claim that you wrote the original software. If you use
      this software in a product, an acknowledgment in the product
      documentation would be appreciated but is not required.

   2. Altered source versions must be plainly marked as such, and
      must not be misrepresented as being the original software.

   3. This notice may not be removed or altered from any source
      distribution.

   The original version of this class can be located at:
   http://irrlicht.suckerfreegames.com/

   John Norman
   john@suckerfreegames.com
*/

#pragma once

#if (__cplusplus > 199711L) || (_MSC_VER >= 1600) || defined(__GXX_EXPERIMENTAL_CXX0X__)
#	define USTRING_CPP0X
#	if defined(__GXX_EXPERIMENTAL_CXX0X__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 5)))
#		define USTRING_CPP0X_NEWLITERALS
#	endif
#endif

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <cstddef>

#ifdef _WIN32
#define __BYTE_ORDER 0
#define __LITTLE_ENDIAN 0
#define __BIG_ENDIAN 1
#elif defined(__MACH__) && defined(__APPLE__)
#include <machine/endian.h>
#elif defined(__FreeBSD__) || defined(__DragonFly__)
#include <sys/endian.h>
#else
#include <endian.h>
#endif

#ifdef USTRING_CPP0X
#	include <utility>
#endif

#ifndef USTRING_NO_STL
#	include <string>
#	include <iterator>
#	include <ostream>
#endif

#include "irrTypes.h"
#include "irrAllocator.h"
#include "irrArray.h"
#include "irrMath.h"
#include "irrString.h"
#include "path.h"

//! UTF-16 surrogate start values.
static const irr::u16 UTF16_HI_SURROGATE = 0xD800;
static const irr::u16 UTF16_LO_SURROGATE = 0xDC00;

//! Is a UTF-16 code point a surrogate?
#define UTF16_IS_SURROGATE(c)		(((c) & 0xF800) == 0xD800)
#define UTF16_IS_SURROGATE_HI(c)	(((c) & 0xFC00) == 0xD800)
#define UTF16_IS_SURROGATE_LO(c)	(((c) & 0xFC00) == 0xDC00)


namespace irr
{

	// Define our character types.
#ifdef USTRING_CPP0X_NEWLITERALS	// C++0x
	typedef char32_t uchar32_t;
	typedef char16_t uchar16_t;
	typedef char uchar8_t;
#else
	typedef u32 uchar32_t;
	typedef u16 uchar16_t;
	typedef u8 uchar8_t;
#endif

namespace core
{

namespace unicode
{

//! The unicode replacement character.  Used to replace invalid characters.
const irr::u16 UTF_REPLACEMENT_CHARACTER = 0xFFFD;

//! Convert a UTF-16 surrogate pair into a UTF-32 character.
//! \param high The high value of the pair.
//! \param low The low value of the pair.
//! \return The UTF-32 character expressed by the surrogate pair.
inline uchar32_t toUTF32(uchar16_t high, uchar16_t low)
{
	// Convert the surrogate pair into a single UTF-32 character.
	uchar32_t x = ((high & ((1 << 6) -1)) << 10) | (low & ((1 << 10) -1));
	uchar32_t wu = ((high >> 6) & ((1 << 5) - 1)) + 1;
	return (wu << 16) | x;
}

//! Swaps the endianness of a 16-bit value.
//! \return The new value.
inline uchar16_t swapEndian16(const uchar16_t& c)
{
	return ((c >> 8) & 0x00FF) | ((c << 8) & 0xFF00);
}

//! Swaps the endianness of a 32-bit value.
//! \return The new value.
inline uchar32_t swapEndian32(const uchar32_t& c)
{
	return  ((c >> 24) & 0x000000FF) |
			((c >> 8)  & 0x0000FF00) |
			((c << 8)  & 0x00FF0000) |
			((c << 24) & 0xFF000000);
}

//! The Unicode byte order mark.
const u16 BOM = 0xFEFF;

//! The size of the Unicode byte order mark in terms of the Unicode character size.
const u8 BOM_UTF8_LEN = 3;
const u8 BOM_UTF16_LEN = 1;
const u8 BOM_UTF32_LEN = 1;

//! Unicode byte order marks for file operations.
const u8 BOM_ENCODE_UTF8[3] = { 0xEF, 0xBB, 0xBF };
const u8 BOM_ENCODE_UTF16_BE[2] = { 0xFE, 0xFF };
const u8 BOM_ENCODE_UTF16_LE[2] = { 0xFF, 0xFE };
const u8 BOM_ENCODE_UTF32_BE[4] = { 0x00, 0x00, 0xFE, 0xFF };
const u8 BOM_ENCODE_UTF32_LE[4] = { 0xFF, 0xFE, 0x00, 0x00 };

//! The size in bytes of the Unicode byte marks for file operations.
const u8 BOM_ENCODE_UTF8_LEN = 3;
const u8 BOM_ENCODE_UTF16_LEN = 2;
const u8 BOM_ENCODE_UTF32_LEN = 4;

//! Unicode encoding type.
enum EUTF_ENCODE
{
	EUTFE_NONE		= 0,
	EUTFE_UTF8,
	EUTFE_UTF16,
	EUTFE_UTF16_LE,
	EUTFE_UTF16_BE,
	EUTFE_UTF32,
	EUTFE_UTF32_LE,
	EUTFE_UTF32_BE
};

//! Unicode endianness.
enum EUTF_ENDIAN
{
	EUTFEE_NATIVE	= 0,
	EUTFEE_LITTLE,
	EUTFEE_BIG
};

//! Returns the specified unicode byte order mark in a byte array.
//! The byte order mark is the first few bytes in a text file that signifies its encoding.
/** \param mode The Unicode encoding method that we want to get the byte order mark for.
		If EUTFE_UTF16 or EUTFE_UTF32 is passed, it uses the native system endianness. **/
//! \return An array that contains a byte order mark.
inline core::array<u8> getUnicodeBOM(EUTF_ENCODE mode)
{
#define COPY_ARRAY(source, size) \
	memcpy(ret.pointer(), source, size); \
	ret.set_used(size)

	core::array<u8> ret(4);
	switch (mode)
	{
		case EUTFE_UTF8:
			COPY_ARRAY(BOM_ENCODE_UTF8, BOM_ENCODE_UTF8_LEN);
			break;
		case EUTFE_UTF16:
			#ifdef __BIG_ENDIAN__
				COPY_ARRAY(BOM_ENCODE_UTF16_BE, BOM_ENCODE_UTF16_LEN);
			#else
				COPY_ARRAY(BOM_ENCODE_UTF16_LE, BOM_ENCODE_UTF16_LEN);
			#endif
			break;
		case EUTFE_UTF16_BE:
			COPY_ARRAY(BOM_ENCODE_UTF16_BE, BOM_ENCODE_UTF16_LEN);
			break;
		case EUTFE_UTF16_LE:
			COPY_ARRAY(BOM_ENCODE_UTF16_LE, BOM_ENCODE_UTF16_LEN);
			break;
		case EUTFE_UTF32:
			#ifdef __BIG_ENDIAN__
				COPY_ARRAY(BOM_ENCODE_UTF32_BE, BOM_ENCODE_UTF32_LEN);
			#else
				COPY_ARRAY(BOM_ENCODE_UTF32_LE, BOM_ENCODE_UTF32_LEN);
			#endif
			break;
		case EUTFE_UTF32_BE:
			COPY_ARRAY(BOM_ENCODE_UTF32_BE, BOM_ENCODE_UTF32_LEN);
			break;
		case EUTFE_UTF32_LE:
			COPY_ARRAY(BOM_ENCODE_UTF32_LE, BOM_ENCODE_UTF32_LEN);
			break;
		case EUTFE_NONE:
			// TODO sapier: fixed warning only,
			// don't know if something needs to be done here
			break;
	}
	return ret;

#undef COPY_ARRAY
}

//! Detects if the given data stream starts with a unicode BOM.
//! \param data The data stream to check.
//! \return The unicode BOM associated with the data stream, or EUTFE_NONE if none was found.
inline EUTF_ENCODE determineUnicodeBOM(const char* data)
{
	if (memcmp(data, BOM_ENCODE_UTF8, 3) == 0) return EUTFE_UTF8;
	if (memcmp(data, BOM_ENCODE_UTF16_BE, 2) == 0) return EUTFE_UTF16_BE;
	if (memcmp(data, BOM_ENCODE_UTF16_LE, 2) == 0) return EUTFE_UTF16_LE;
	if (memcmp(data, BOM_ENCODE_UTF32_BE, 4) == 0) return EUTFE_UTF32_BE;
	if (memcmp(data, BOM_ENCODE_UTF32_LE, 4) == 0) return EUTFE_UTF32_LE;
	return EUTFE_NONE;
}

} // end namespace unicode


//! UTF-16 string class.
template <typename TAlloc = irrAllocator<uchar16_t> >
class ustring16
{
public:

	///------------------///
	/// iterator classes ///
	///------------------///

	//! Access an element in a unicode string, allowing one to change it.
	class _ustring16_iterator_access
	{
		public:
			_ustring16_iterator_access(const ustring16<TAlloc>* s, u32 p) : ref(s), pos(p) {}

			//! Allow the class to be interpreted as a single UTF-32 character.
			operator uchar32_t() const
			{
				return _get();
			}

			//! Allow one to change the character in the unicode string.
			//! \param c The new character to use.
			//! \return Myself.
			_ustring16_iterator_access& operator=(const uchar32_t c)
			{
				_set(c);
				return *this;
			}

			//! Increments the value by 1.
			//! \return Myself.
			_ustring16_iterator_access& operator++()
			{
				_set(_get() + 1);
				return *this;
			}

			//! Increments the value by 1, returning the old value.
			//! \return A unicode character.
			uchar32_t operator++(int)
			{
				uchar32_t old = _get();
				_set(old + 1);
				return old;
			}

			//! Decrements the value by 1.
			//! \return Myself.
			_ustring16_iterator_access& operator--()
			{
				_set(_get() - 1);
				return *this;
			}

			//! Decrements the value by 1, returning the old value.
			//! \return A unicode character.
			uchar32_t operator--(int)
			{
				uchar32_t old = _get();
				_set(old - 1);
				return old;
			}

			//! Adds to the value by a specified amount.
			//! \param val The amount to add to this character.
			//! \return Myself.
			_ustring16_iterator_access& operator+=(int val)
			{
				_set(_get() + val);
				return *this;
			}

			//! Subtracts from the value by a specified amount.
			//! \param val The amount to subtract from this character.
			//! \return Myself.
			_ustring16_iterator_access& operator-=(int val)
			{
				_set(_get() - val);
				return *this;
			}

			//! Multiples the value by a specified amount.
			//! \param val The amount to multiply this character by.
			//! \return Myself.
			_ustring16_iterator_access& operator*=(int val)
			{
				_set(_get() * val);
				return *this;
			}

			//! Divides the value by a specified amount.
			//! \param val The amount to divide this character by.
			//! \return Myself.
			_ustring16_iterator_access& operator/=(int val)
			{
				_set(_get() / val);
				return *this;
			}

			//! Modulos the value by a specified amount.
			//! \param val The amount to modulo this character by.
			//! \return Myself.
			_ustring16_iterator_access& operator%=(int val)
			{
				_set(_get() % val);
				return *this;
			}

			//! Adds to the value by a specified amount.
			//! \param val The amount to add to this character.
			//! \return A unicode character.
			uchar32_t operator+(int val) const
			{
				return _get() + val;
			}

			//! Subtracts from the value by a specified amount.
			//! \param val The amount to subtract from this character.
			//! \return A unicode character.
			uchar32_t operator-(int val) const
			{
				return _get() - val;
			}

			//! Multiplies the value by a specified amount.
			//! \param val The amount to multiply this character by.
			//! \return A unicode character.
			uchar32_t operator*(int val) const
			{
				return _get() * val;
			}

			//! Divides the value by a specified amount.
			//! \param val The amount to divide this character by.
			//! \return A unicode character.
			uchar32_t operator/(int val) const
			{
				return _get() / val;
			}

			//! Modulos the value by a specified amount.
			//! \param val The amount to modulo this character by.
			//! \return A unicode character.
			uchar32_t operator%(int val) const
			{
				return _get() % val;
			}

		private:
			//! Gets a uchar32_t from our current position.
			uchar32_t _get() const
			{
				const uchar16_t* a = ref->c_str();
				if (!UTF16_IS_SURROGATE(a[pos]))
					return static_cast<uchar32_t>(a[pos]);
				else
				{
					if (pos + 1 >= ref->size_raw())
						return 0;

					return unicode::toUTF32(a[pos], a[pos + 1]);
				}
			}

			//! Sets a uchar32_t at our current position.
			void _set(uchar32_t c)
			{
				ustring16<TAlloc>* ref2 = const_cast<ustring16<TAlloc>*>(ref);
				const uchar16_t* a = ref2->c_str();
				if (c > 0xFFFF)
				{
					// c will be multibyte, so split it up into the high and low surrogate pairs.
					uchar16_t x = static_cast<uchar16_t>(c);
					uchar16_t vh = UTF16_HI_SURROGATE | ((((c >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
					uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));

					// If the previous position was a surrogate pair, just replace them.  Else, insert the low pair.
					if (UTF16_IS_SURROGATE_HI(a[pos]) && pos + 1 != ref2->size_raw())
						ref2->replace_raw(vl, static_cast<u32>(pos) + 1);
					else ref2->insert_raw(vl, static_cast<u32>(pos) + 1);

					ref2->replace_raw(vh, static_cast<u32>(pos));
				}
				else
				{
					// c will be a single byte.
					uchar16_t vh = static_cast<uchar16_t>(c);

					// If the previous position was a surrogate pair, remove the extra byte.
					if (UTF16_IS_SURROGATE_HI(a[pos]))
						ref2->erase_raw(static_cast<u32>(pos) + 1);

					ref2->replace_raw(vh, static_cast<u32>(pos));
				}
			}

			const ustring16<TAlloc>* ref;
			u32 pos;
	};
	typedef typename ustring16<TAlloc>::_ustring16_iterator_access access;


	//! Iterator to iterate through a UTF-16 string.
#ifndef USTRING_NO_STL
	class _ustring16_const_iterator : public std::iterator<
		std::bidirectional_iterator_tag,	// iterator_category
		access,								// value_type
		ptrdiff_t,							// difference_type
		const access,						// pointer
		const access						// reference
	>
#else
	class _ustring16_const_iterator
#endif
	{
		public:
			typedef _ustring16_const_iterator _Iter;
			typedef std::iterator<std::bidirectional_iterator_tag, access, ptrdiff_t, const access, const access> _Base;
			typedef const access const_pointer;
			typedef const access const_reference;

#ifndef USTRING_NO_STL
			typedef typename _Base::value_type value_type;
			typedef typename _Base::difference_type difference_type;
			typedef typename _Base::difference_type distance_type;
			typedef typename _Base::pointer pointer;
			typedef const_reference reference;
#else
			typedef access value_type;
			typedef u32 difference_type;
			typedef u32 distance_type;
			typedef const_pointer pointer;
			typedef const_reference reference;
#endif

			//! Constructors.
			_ustring16_const_iterator(const _Iter& i) : ref(i.ref), pos(i.pos) {}
			_ustring16_const_iterator(const ustring16<TAlloc>& s) : ref(&s), pos(0) {}
			_ustring16_const_iterator(const ustring16<TAlloc>& s, const u32 p) : ref(&s), pos(0)
			{
				if (ref->size_raw() == 0 || p == 0)
					return;

				// Go to the appropriate position.
				u32 i = p;
				u32 sr = ref->size_raw();
				const uchar16_t* a = ref->c_str();
				while (i != 0 && pos < sr)
				{
					if (UTF16_IS_SURROGATE_HI(a[pos]))
						pos += 2;
					else ++pos;
					--i;
				}
			}

			//! Test for equalness.
			bool operator==(const _Iter& iter) const
			{
				if (ref == iter.ref && pos == iter.pos)
					return true;
				return false;
			}

			//! Test for unequalness.
			bool operator!=(const _Iter& iter) const
			{
				if (ref != iter.ref || pos != iter.pos)
					return true;
				return false;
			}

			//! Switch to the next full character in the string.
			_Iter& operator++()
			{	// ++iterator
				if (pos == ref->size_raw()) return *this;
				const uchar16_t* a = ref->c_str();
				if (UTF16_IS_SURROGATE_HI(a[pos]))
					pos += 2;			// TODO: check for valid low surrogate?
				else ++pos;
				if (pos > ref->size_raw()) pos = ref->size_raw();
				return *this;
			}

			//! Switch to the next full character in the string, returning the previous position.
			_Iter operator++(int)
			{	// iterator++
				_Iter _tmp(*this);
				++*this;
				return _tmp;
			}

			//! Switch to the previous full character in the string.
			_Iter& operator--()
			{	// --iterator
				if (pos == 0) return *this;
				const uchar16_t* a = ref->c_str();
				--pos;
				if (UTF16_IS_SURROGATE_LO(a[pos]) && pos != 0)	// low surrogate, go back one more.
					--pos;
				return *this;
			}

			//! Switch to the previous full character in the string, returning the previous position.
			_Iter operator--(int)
			{	// iterator--
				_Iter _tmp(*this);
				--*this;
				return _tmp;
			}

			//! Advance a specified number of full characters in the string.
			//! \return Myself.
			_Iter& operator+=(const difference_type v)
			{
				if (v == 0) return *this;
				if (v < 0) return operator-=(v * -1);

				if (pos >= ref->size_raw())
					return *this;

				// Go to the appropriate position.
				// TODO: Don't force u32 on an x64 OS.  Make it agnostic.
				u32 i = (u32)v;
				u32 sr = ref->size_raw();
				const uchar16_t* a = ref->c_str();
				while (i != 0 && pos < sr)
				{
					if (UTF16_IS_SURROGATE_HI(a[pos]))
						pos += 2;
					else ++pos;
					--i;
				}
				if (pos > sr)
					pos = sr;

				return *this;
			}

			//! Go back a specified number of full characters in the string.
			//! \return Myself.
			_Iter& operator-=(const difference_type v)
			{
				if (v == 0) return *this;
				if (v > 0) return operator+=(v * -1);

				if (pos == 0)
					return *this;

				// Go to the appropriate position.
				// TODO: Don't force u32 on an x64 OS.  Make it agnostic.
				u32 i = (u32)v;
				const uchar16_t* a = ref->c_str();
				while (i != 0 && pos != 0)
				{
					--pos;
					if (UTF16_IS_SURROGATE_LO(a[pos]) != 0 && pos != 0)
						--pos;
					--i;
				}

				return *this;
			}

			//! Return a new iterator that is a variable number of full characters forward from the current position.
			_Iter operator+(const difference_type v) const
			{
				_Iter ret(*this);
				ret += v;
				return ret;
			}

			//! Return a new iterator that is a variable number of full characters backward from the current position.
			_Iter operator-(const difference_type v) const
			{
				_Iter ret(*this);
				ret -= v;
				return ret;
			}

			//! Returns the distance between two iterators.
			difference_type operator-(const _Iter& iter) const
			{
				// Make sure we reference the same object!
				if (ref != iter.ref)
					return difference_type();

				_Iter i = iter;
				difference_type ret;

				// Walk up.
				if (pos > i.pos)
				{
					while (pos > i.pos)
					{
						++i;
						++ret;
					}
					return ret;
				}

				// Walk down.
				while (pos < i.pos)
				{
					--i;
					--ret;
				}
				return ret;
			}

			//! Accesses the full character at the iterator's position.
			const_reference operator*() const
			{
				if (pos >= ref->size_raw())
				{
					const uchar16_t* a = ref->c_str();
					u32 p = ref->size_raw();
					if (UTF16_IS_SURROGATE_LO(a[p]))
						--p;
					reference ret(ref, p);
					return ret;
				}
				const_reference ret(ref, pos);
				return ret;
			}

			//! Accesses the full character at the iterator's position.
			reference operator*()
			{
				if (pos >= ref->size_raw())
				{
					const uchar16_t* a = ref->c_str();
					u32 p = ref->size_raw();
					if (UTF16_IS_SURROGATE_LO(a[p]))
						--p;
					reference ret(ref, p);
					return ret;
				}
				reference ret(ref, pos);
				return ret;
			}

			//! Accesses the full character at the iterator's position.
			const_pointer operator->() const
			{
				return operator*();
			}

			//! Accesses the full character at the iterator's position.
			pointer operator->()
			{
				return operator*();
			}

			//! Is the iterator at the start of the string?
			bool atStart() const
			{
				return pos == 0;
			}

			//! Is the iterator at the end of the string?
			bool atEnd() const
			{
				const uchar16_t* a = ref->c_str();
				if (UTF16_IS_SURROGATE(a[pos]))
					return (pos + 1) >= ref->size_raw();
				else return pos >= ref->size_raw();
			}

			//! Moves the iterator to the start of the string.
			void toStart()
			{
				pos = 0;
			}

			//! Moves the iterator to the end of the string.
			void toEnd()
			{
				pos = ref->size_raw();
			}

			//! Returns the iterator's position.
			//! \return The iterator's position.
			u32 getPos() const
			{
				return pos;
			}

		protected:
			const ustring16<TAlloc>* ref;
			u32 pos;
	};

	//! Iterator to iterate through a UTF-16 string.
	class _ustring16_iterator : public _ustring16_const_iterator
	{
		public:
			typedef _ustring16_iterator _Iter;
			typedef _ustring16_const_iterator _Base;
			typedef typename _Base::const_pointer const_pointer;
			typedef typename _Base::const_reference const_reference;


			typedef typename _Base::value_type value_type;
			typedef typename _Base::difference_type difference_type;
			typedef typename _Base::distance_type distance_type;
			typedef access pointer;
			typedef access reference;

			using _Base::pos;
			using _Base::ref;

			//! Constructors.
			_ustring16_iterator(const _Iter& i) : _ustring16_const_iterator(i) {}
			_ustring16_iterator(const ustring16<TAlloc>& s) : _ustring16_const_iterator(s) {}
			_ustring16_iterator(const ustring16<TAlloc>& s, const u32 p) : _ustring16_const_iterator(s, p) {}

			//! Accesses the full character at the iterator's position.
			reference operator*() const
			{
				if (pos >= ref->size_raw())
				{
					const uchar16_t* a = ref->c_str();
					u32 p = ref->size_raw();
					if (UTF16_IS_SURROGATE_LO(a[p]))
						--p;
					reference ret(ref, p);
					return ret;
				}
				reference ret(ref, pos);
				return ret;
			}

			//! Accesses the full character at the iterator's position.
			reference operator*()
			{
				if (pos >= ref->size_raw())
				{
					const uchar16_t* a = ref->c_str();
					u32 p = ref->size_raw();
					if (UTF16_IS_SURROGATE_LO(a[p]))
						--p;
					reference ret(ref, p);
					return ret;
				}
				reference ret(ref, pos);
				return ret;
			}

			//! Accesses the full character at the iterator's position.
			pointer operator->() const
			{
				return operator*();
			}

			//! Accesses the full character at the iterator's position.
			pointer operator->()
			{
				return operator*();
			}
	};

	typedef typename ustring16<TAlloc>::_ustring16_iterator iterator;
	typedef typename ustring16<TAlloc>::_ustring16_const_iterator const_iterator;

	///----------------------///
	/// end iterator classes ///
	///----------------------///

	//! Default constructor
	ustring16()
	: array(0), allocated(1), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif
		array = allocator.allocate(1); // new u16[1];
		array[0] = 0x0;
	}


	//! Constructor
	ustring16(const ustring16<TAlloc>& other)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif
		*this = other;
	}


	//! Constructor from other string types
	template <class B, class A>
	ustring16(const string<B, A>& other)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif
		*this = other;
	}


#ifndef USTRING_NO_STL
	//! Constructor from std::string
	template <class B, class A, typename Alloc>
	ustring16(const std::basic_string<B, A, Alloc>& other)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif
		*this = other.c_str();
	}


	//! Constructor from iterator.
	template <typename Itr>
	ustring16(Itr first, Itr last)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif
		reserve(std::distance(first, last));
		array[used] = 0;

		for (; first != last; ++first)
			append((uchar32_t)*first);
	}
#endif


#ifndef USTRING_CPP0X_NEWLITERALS
	//! Constructor for copying a character string from a pointer.
	ustring16(const char* const c)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif

		loadDataStream(c, strlen(c));
		//append((uchar8_t*)c);
	}


	//! Constructor for copying a character string from a pointer with a given length.
	ustring16(const char* const c, u32 length)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif

		loadDataStream(c, length);
	}
#endif


	//! Constructor for copying a UTF-8 string from a pointer.
	ustring16(const uchar8_t* const c)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif

		append(c);
	}


	//! Constructor for copying a UTF-8 string from a single char.
	ustring16(const char c)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif

		append((uchar32_t)c);
	}


	//! Constructor for copying a UTF-8 string from a pointer with a given length.
	ustring16(const uchar8_t* const c, u32 length)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif

		append(c, length);
	}


	//! Constructor for copying a UTF-16 string from a pointer.
	ustring16(const uchar16_t* const c)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif

		append(c);
	}


	//! Constructor for copying a UTF-16 string from a pointer with a given length
	ustring16(const uchar16_t* const c, u32 length)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif

		append(c, length);
	}


	//! Constructor for copying a UTF-32 string from a pointer.
	ustring16(const uchar32_t* const c)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif

		append(c);
	}


	//! Constructor for copying a UTF-32 from a pointer with a given length.
	ustring16(const uchar32_t* const c, u32 length)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif

		append(c, length);
	}


	//! Constructor for copying a wchar_t string from a pointer.
	ustring16(const wchar_t* const c)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif

		if (sizeof(wchar_t) == 4)
			append(reinterpret_cast<const uchar32_t* const>(c));
		else if (sizeof(wchar_t) == 2)
			append(reinterpret_cast<const uchar16_t* const>(c));
		else if (sizeof(wchar_t) == 1)
			append(reinterpret_cast<const uchar8_t* const>(c));
	}


	//! Constructor for copying a wchar_t string from a pointer with a given length.
	ustring16(const wchar_t* const c, u32 length)
	: array(0), allocated(0), used(0)
	{
#if __BYTE_ORDER == __BIG_ENDIAN
		encoding = unicode::EUTFE_UTF16_BE;
#else
		encoding = unicode::EUTFE_UTF16_LE;
#endif

		if (sizeof(wchar_t) == 4)
			append(reinterpret_cast<const uchar32_t* const>(c), length);
		else if (sizeof(wchar_t) == 2)
			append(reinterpret_cast<const uchar16_t* const>(c), length);
		else if (sizeof(wchar_t) == 1)
			append(reinterpret_cast<const uchar8_t* const>(c), length);
	}


#ifdef USTRING_CPP0X
	//! Constructor for moving a ustring16
	ustring16(ustring16<TAlloc>&& other)
	: array(other.array), encoding(other.encoding), allocated(other.allocated), used(other.used)
	{
		//std::cout << "MOVE constructor" << std::endl;
		other.array = 0;
		other.allocated = 0;
		other.used = 0;
	}
#endif


	//! Destructor
	~ustring16()
	{
		allocator.deallocate(array); // delete [] array;
	}


	//! Assignment operator
	ustring16& operator=(const ustring16<TAlloc>& other)
	{
		if (this == &other)
			return *this;

		used = other.size_raw();
		if (used >= allocated)
		{
			allocator.deallocate(array); // delete [] array;
			allocated = used + 1;
			array = allocator.allocate(used + 1); //new u16[used];
		}

		const uchar16_t* p = other.c_str();
		for (u32 i=0; i<=used; ++i, ++p)
			array[i] = *p;

		array[used] = 0;

		// Validate our new UTF-16 string.
		validate();

		return *this;
	}


#ifdef USTRING_CPP0X
	//! Move assignment operator
	ustring16& operator=(ustring16<TAlloc>&& other)
	{
		if (this != &other)
		{
			//std::cout << "MOVE operator=" << std::endl;
			allocator.deallocate(array);

			array = other.array;
			allocated = other.allocated;
			encoding = other.encoding;
			used = other.used;
			other.array = 0;
			other.used = 0;
		}
		return *this;
	}
#endif


	//! Assignment operator for other string types
	template <class B, class A>
	ustring16<TAlloc>& operator=(const string<B, A>& other)
	{
		*this = other.c_str();
		return *this;
	}


	//! Assignment operator for UTF-8 strings
	ustring16<TAlloc>& operator=(const uchar8_t* const c)
	{
		if (!array)
		{
			array = allocator.allocate(1); //new u16[1];
			allocated = 1;
		}
		used = 0;
		array[used] = 0x0;
		if (!c) return *this;

		//! Append our string now.
		append(c);
		return *this;
	}


	//! Assignment operator for UTF-16 strings
	ustring16<TAlloc>& operator=(const uchar16_t* const c)
	{
		if (!array)
		{
			array = allocator.allocate(1); //new u16[1];
			allocated = 1;
		}
		used = 0;
		array[used] = 0x0;
		if (!c) return *this;

		//! Append our string now.
		append(c);
		return *this;
	}


	//! Assignment operator for UTF-32 strings
	ustring16<TAlloc>& operator=(const uchar32_t* const c)
	{
		if (!array)
		{
			array = allocator.allocate(1); //new u16[1];
			allocated = 1;
		}
		used = 0;
		array[used] = 0x0;
		if (!c) return *this;

		//! Append our string now.
		append(c);
		return *this;
	}


	//! Assignment operator for wchar_t strings.
	/** Note that this assumes that a correct unicode string is stored in the wchar_t string.
		Since wchar_t changes depending on its platform, it could either be a UTF-8, -16, or -32 string.
		This function assumes you are storing the correct unicode encoding inside the wchar_t string. **/
	ustring16<TAlloc>& operator=(const wchar_t* const c)
	{
		if (sizeof(wchar_t) == 4)
			*this = reinterpret_cast<const uchar32_t* const>(c);
		else if (sizeof(wchar_t) == 2)
			*this = reinterpret_cast<const uchar16_t* const>(c);
		else if (sizeof(wchar_t) == 1)
			*this = reinterpret_cast<const uchar8_t* const>(c);

		return *this;
	}


	//! Assignment operator for other strings.
	/** Note that this assumes that a correct unicode string is stored in the string. **/
	template <class B>
	ustring16<TAlloc>& operator=(const B* const c)
	{
		if (sizeof(B) == 4)
			*this = reinterpret_cast<const uchar32_t* const>(c);
		else if (sizeof(B) == 2)
			*this = reinterpret_cast<const uchar16_t* const>(c);
		else if (sizeof(B) == 1)
			*this = reinterpret_cast<const uchar8_t* const>(c);

		return *this;
	}


	//! Direct access operator
	access operator [](const u32 index)
	{
		_IRR_DEBUG_BREAK_IF(index>=size()) // bad index
		iterator iter(*this, index);
		return iter.operator*();
	}


	//! Direct access operator
	const access operator [](const u32 index) const
	{
		_IRR_DEBUG_BREAK_IF(index>=size()) // bad index
		const_iterator iter(*this, index);
		return iter.operator*();
	}


	//! Equality operator
	bool operator ==(const uchar16_t* const str) const
	{
		if (!str)
			return false;

		u32 i;
		for(i=0; array[i] && str[i]; ++i)
			if (array[i] != str[i])
				return false;

		return !array[i] && !str[i];
	}


	//! Equality operator
	bool operator ==(const ustring16<TAlloc>& other) const
	{
		for(u32 i=0; array[i] && other.array[i]; ++i)
			if (array[i] != other.array[i])
				return false;

		return used == other.used;
	}


	//! Is smaller comparator
	bool operator <(const ustring16<TAlloc>& other) const
	{
		for(u32 i=0; array[i] && other.array[i]; ++i)
		{
			s32 diff = array[i] - other.array[i];
			if ( diff )
				return diff < 0;
		}

		return used < other.used;
	}


	//! Inequality operator
	bool operator !=(const uchar16_t* const str) const
	{
		return !(*this == str);
	}


	//! Inequality operator
	bool operator !=(const ustring16<TAlloc>& other) const
	{
		return !(*this == other);
	}


	//! Returns the length of a ustring16 in full characters.
	//! \return Length of a ustring16 in full characters.
	u32 size() const
	{
		const_iterator i(*this, 0);
		u32 pos = 0;
		while (!i.atEnd())
		{
			++i;
			++pos;
		}
		return pos;
	}


	//! Informs if the ustring is empty or not.
	//! \return True if the ustring is empty, false if not.
	bool empty() const
	{
		return (size_raw() == 0);
	}


	//! Returns a pointer to the raw UTF-16 string data.
	//! \return pointer to C-style NUL terminated array of UTF-16 code points.
	const uchar16_t* c_str() const
	{
		return array;
	}


	//! Compares the first n characters of this string with another.
	//! \param other Other string to compare to.
	//! \param n Number of characters to compare.
	//! \return True if the n first characters of both strings are equal.
	bool equalsn(const ustring16<TAlloc>& other, u32 n) const
	{
		u32 i;
		const uchar16_t* oa = other.c_str();
		for(i=0; array[i] && oa[i] && i < n; ++i)
			if (array[i] != oa[i])
				return false;

		// if one (or both) of the strings was smaller then they
		// are only equal if they have the same length
		return (i == n) || (used == other.used);
	}


	//! Compares the first n characters of this string with another.
	//! \param str Other string to compare to.
	//! \param n Number of characters to compare.
	//! \return True if the n first characters of both strings are equal.
	bool equalsn(const uchar16_t* const str, u32 n) const
	{
		if (!str)
			return false;
		u32 i;
		for(i=0; array[i] && str[i] && i < n; ++i)
			if (array[i] != str[i])
				return false;

		// if one (or both) of the strings was smaller then they
		// are only equal if they have the same length
		return (i == n) || (array[i] == 0 && str[i] == 0);
	}


	//! Appends a character to this ustring16
	//! \param character The character to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& append(uchar32_t character)
	{
		if (used + 2 >= allocated)
			reallocate(used + 2);

		if (character > 0xFFFF)
		{
			used += 2;

			// character will be multibyte, so split it up into a surrogate pair.
			uchar16_t x = static_cast<uchar16_t>(character);
			uchar16_t vh = UTF16_HI_SURROGATE | ((((character >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
			uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
			array[used-2] = vh;
			array[used-1] = vl;
		}
		else
		{
			++used;
			array[used-1] = character;
		}
		array[used] = 0;

		return *this;
	}


	//! Appends a UTF-8 string to this ustring16
	//! \param other The UTF-8 string to append.
	//! \param length The length of the string to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& append(const uchar8_t* const other, u32 length=0xffffffff)
	{
		if (!other)
			return *this;

		// Determine if the string is long enough for a BOM.
		u32 len = 0;
		const uchar8_t* p = other;
		do
		{
			++len;
		} while (*p++ && len < unicode::BOM_ENCODE_UTF8_LEN);

		// Check for BOM.
		unicode::EUTF_ENCODE c_bom = unicode::EUTFE_NONE;
		if (len == unicode::BOM_ENCODE_UTF8_LEN)
		{
			if (memcmp(other, unicode::BOM_ENCODE_UTF8, unicode::BOM_ENCODE_UTF8_LEN) == 0)
				c_bom = unicode::EUTFE_UTF8;
		}

		// If a BOM was found, don't include it in the string.
		const uchar8_t* c2 = other;
		if (c_bom != unicode::EUTFE_NONE)
		{
			c2 = other + unicode::BOM_UTF8_LEN;
			length -= unicode::BOM_UTF8_LEN;
		}

		// Calculate the size of the string to read in.
		len = 0;
		p = c2;
		do
		{
			++len;
		} while(*p++ && len < length);
		if (len > length)
			len = length;

		// If we need to grow the array, do it now.
		if (used + len >= allocated)
			reallocate(used + (len * 2));
		u32 start = used;

		// Convert UTF-8 to UTF-16.
		u32 pos = start;
		for (u32 l = 0; l<len;)
		{
			++used;
			if (((c2[l] >> 6) & 0x03) == 0x02)
			{	// Invalid continuation byte.
				array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
				++l;
			}
			else if (c2[l] == 0xC0 || c2[l] == 0xC1)
			{	// Invalid byte - overlong encoding.
				array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
				++l;
			}
			else if ((c2[l] & 0xF8) == 0xF0)
			{	// 4 bytes UTF-8, 2 bytes UTF-16.
				// Check for a full string.
				if ((l + 3) >= len)
				{
					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
					l += 3;
					break;
				}

				// Validate.
				bool valid = true;
				u8 l2 = 0;
				if (valid && (((c2[l+1] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
				if (valid && (((c2[l+2] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
				if (valid && (((c2[l+3] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
				if (!valid)
				{
					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
					l += l2;
					continue;
				}

				// Decode.
				uchar8_t b1 = ((c2[l] & 0x7) << 2) | ((c2[l+1] >> 4) & 0x3);
				uchar8_t b2 = ((c2[l+1] & 0xF) << 4) | ((c2[l+2] >> 2) & 0xF);
				uchar8_t b3 = ((c2[l+2] & 0x3) << 6) | (c2[l+3] & 0x3F);
				uchar32_t v = b3 | ((uchar32_t)b2 << 8) | ((uchar32_t)b1 << 16);

				// Split v up into a surrogate pair.
				uchar16_t x = static_cast<uchar16_t>(v);
				uchar16_t vh = UTF16_HI_SURROGATE | ((((v >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
				uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));

				array[pos++] = vh;
				array[pos++] = vl;
				l += 4;
				++used;		// Using two shorts this time, so increase used by 1.
			}
			else if ((c2[l] & 0xF0) == 0xE0)
			{	// 3 bytes UTF-8, 1 byte UTF-16.
				// Check for a full string.
				if ((l + 2) >= len)
				{
					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
					l += 2;
					break;
				}

				// Validate.
				bool valid = true;
				u8 l2 = 0;
				if (valid && (((c2[l+1] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
				if (valid && (((c2[l+2] >> 6) & 0x03) == 0x02)) ++l2; else valid = false;
				if (!valid)
				{
					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
					l += l2;
					continue;
				}

				// Decode.
				uchar8_t b1 = ((c2[l] & 0xF) << 4) | ((c2[l+1] >> 2) & 0xF);
				uchar8_t b2 = ((c2[l+1] & 0x3) << 6) | (c2[l+2] & 0x3F);
				uchar16_t ch = b2 | ((uchar16_t)b1 << 8);
				array[pos++] = ch;
				l += 3;
			}
			else if ((c2[l] & 0xE0) == 0xC0)
			{	// 2 bytes UTF-8, 1 byte UTF-16.
				// Check for a full string.
				if ((l + 1) >= len)
				{
					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
					l += 1;
					break;
				}

				// Validate.
				if (((c2[l+1] >> 6) & 0x03) != 0x02)
				{
					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
					++l;
					continue;
				}

				// Decode.
				uchar8_t b1 = (c2[l] >> 2) & 0x7;
				uchar8_t b2 = ((c2[l] & 0x3) << 6) | (c2[l+1] & 0x3F);
				uchar16_t ch = b2 | ((uchar16_t)b1 << 8);
				array[pos++] = ch;
				l += 2;
			}
			else
			{	// 1 byte UTF-8, 1 byte UTF-16.
				// Validate.
				if (c2[l] > 0x7F)
				{	// Values above 0xF4 are restricted and aren't used.  By now, anything above 0x7F is invalid.
					array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
				}
				else array[pos++] = static_cast<uchar16_t>(c2[l]);
				++l;
			}
		}
		array[used] = 0;

		// Validate our new UTF-16 string.
		validate();

		return *this;
	}


	//! Appends a UTF-16 string to this ustring16
	//! \param other The UTF-16 string to append.
	//! \param length The length of the string to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& append(const uchar16_t* const other, u32 length=0xffffffff)
	{
		if (!other)
			return *this;

		// Determine if the string is long enough for a BOM.
		u32 len = 0;
		const uchar16_t* p = other;
		do
		{
			++len;
		} while (*p++ && len < unicode::BOM_ENCODE_UTF16_LEN);

		// Check for the BOM to determine the string's endianness.
		unicode::EUTF_ENDIAN c_end = unicode::EUTFEE_NATIVE;
		if (memcmp(other, unicode::BOM_ENCODE_UTF16_LE, unicode::BOM_ENCODE_UTF16_LEN) == 0)
			c_end = unicode::EUTFEE_LITTLE;
		else if (memcmp(other, unicode::BOM_ENCODE_UTF16_BE, unicode::BOM_ENCODE_UTF16_LEN) == 0)
			c_end = unicode::EUTFEE_BIG;

		// If a BOM was found, don't include it in the string.
		const uchar16_t* c2 = other;
		if (c_end != unicode::EUTFEE_NATIVE)
		{
			c2 = other + unicode::BOM_UTF16_LEN;
			length -= unicode::BOM_UTF16_LEN;
		}

		// Calculate the size of the string to read in.
		len = 0;
		p = c2;
		do
		{
			++len;
		} while(*p++ && len < length);
		if (len > length)
			len = length;

		// If we need to grow the size of the array, do it now.
		if (used + len >= allocated)
			reallocate(used + (len * 2));
		u32 start = used;
		used += len;

		// Copy the string now.
		unicode::EUTF_ENDIAN m_end = getEndianness();
		for (u32 l = start; l < start + len; ++l)
		{
			array[l] = (uchar16_t)c2[l];
			if (c_end != unicode::EUTFEE_NATIVE && c_end != m_end)
				array[l] = unicode::swapEndian16(array[l]);
		}

		array[used] = 0;

		// Validate our new UTF-16 string.
		validate();
		return *this;
	}


	//! Appends a UTF-32 string to this ustring16
	//! \param other The UTF-32 string to append.
	//! \param length The length of the string to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& append(const uchar32_t* const other, u32 length=0xffffffff)
	{
		if (!other)
			return *this;

		// Check for the BOM to determine the string's endianness.
		unicode::EUTF_ENDIAN c_end = unicode::EUTFEE_NATIVE;
		if (memcmp(other, unicode::BOM_ENCODE_UTF32_LE, unicode::BOM_ENCODE_UTF32_LEN) == 0)
			c_end = unicode::EUTFEE_LITTLE;
		else if (memcmp(other, unicode::BOM_ENCODE_UTF32_BE, unicode::BOM_ENCODE_UTF32_LEN) == 0)
			c_end = unicode::EUTFEE_BIG;

		// If a BOM was found, don't include it in the string.
		const uchar32_t* c2 = other;
		if (c_end != unicode::EUTFEE_NATIVE)
		{
			c2 = other + unicode::BOM_UTF32_LEN;
			length -= unicode::BOM_UTF32_LEN;
		}

		// Calculate the size of the string to read in.
		u32 len = 0;
		const uchar32_t* p = c2;
		do
		{
			++len;
		} while(*p++ && len < length);
		if (len > length)
			len = length;

		// If we need to grow the size of the array, do it now.
		// In case all of the UTF-32 string is split into surrogate pairs, do len * 2.
		if (used + (len * 2) >= allocated)
			reallocate(used + ((len * 2) * 2));
		u32 start = used;

		// Convert UTF-32 to UTF-16.
		unicode::EUTF_ENDIAN m_end = getEndianness();
		u32 pos = start;
		for (u32 l = 0; l<len; ++l)
		{
			++used;

			uchar32_t ch = c2[l];
			if (c_end != unicode::EUTFEE_NATIVE && c_end != m_end)
				ch = unicode::swapEndian32(ch);

			if (ch > 0xFFFF)
			{
				// Split ch up into a surrogate pair as it is over 16 bits long.
				uchar16_t x = static_cast<uchar16_t>(ch);
				uchar16_t vh = UTF16_HI_SURROGATE | ((((ch >> 16) & ((1 << 5) - 1)) - 1) << 6) | (x >> 10);
				uchar16_t vl = UTF16_LO_SURROGATE | (x & ((1 << 10) - 1));
				array[pos++] = vh;
				array[pos++] = vl;
				++used;		// Using two shorts, so increased used again.
			}
			else if (ch >= 0xD800 && ch <= 0xDFFF)
			{
				// Between possible UTF-16 surrogates (invalid!)
				array[pos++] = unicode::UTF_REPLACEMENT_CHARACTER;
			}
			else array[pos++] = static_cast<uchar16_t>(ch);
		}
		array[used] = 0;

		// Validate our new UTF-16 string.
		validate();

		return *this;
	}


	//! Appends a ustring16 to this ustring16
	//! \param other The string to append to this one.
	//! \return A reference to our current string.
	ustring16<TAlloc>& append(const ustring16<TAlloc>& other)
	{
		const uchar16_t* oa = other.c_str();

		u32 len = other.size_raw();

		if (used + len >= allocated)
			reallocate(used + len);

		for (u32 l=0; l<len; ++l)
			array[used+l] = oa[l];

		used += len;
		array[used] = 0;

		return *this;
	}


	//! Appends a certain amount of characters of a ustring16 to this ustring16.
	//! \param other The string to append to this one.
	//! \param length How many characters of the other string to add to this one.
	//! \return A reference to our current string.
	ustring16<TAlloc>& append(const ustring16<TAlloc>& other, u32 length)
	{
		if (other.size() == 0)
			return *this;

		if (other.size() < length)
		{
			append(other);
			return *this;
		}

		if (used + length * 2 >= allocated)
			reallocate(used + length * 2);

		const_iterator iter(other, 0);
		u32 l = length;
		while (!iter.atEnd() && l)
		{
			uchar32_t c = *iter;
			append(c);
			++iter;
			--l;
		}

		return *this;
	}


	//! Reserves some memory.
	//! \param count The amount of characters to reserve.
	void reserve(u32 count)
	{
		if (count < allocated)
			return;

		reallocate(count);
	}


	//! Finds first occurrence of character.
	//! \param c The character to search for.
	//! \return Position where the character has been found, or -1 if not found.
	s32 findFirst(uchar32_t c) const
	{
		const_iterator i(*this, 0);

		s32 pos = 0;
		while (!i.atEnd())
		{
			uchar32_t t = *i;
			if (c == t)
				return pos;
			++pos;
			++i;
		}

		return -1;
	}

	//! Finds first occurrence of a character of a list.
	//! \param c A list of characters to find. For example if the method should find the first occurrence of 'a' or 'b', this parameter should be "ab".
	//! \param count The amount of characters in the list. Usually, this should be strlen(c).
	//! \return Position where one of the characters has been found, or -1 if not found.
	s32 findFirstChar(const uchar32_t* const c, u32 count=1) const
	{
		if (!c || !count)
			return -1;

		const_iterator i(*this, 0);

		s32 pos = 0;
		while (!i.atEnd())
		{
			uchar32_t t = *i;
			for (u32 j=0; j<count; ++j)
				if (t == c[j])
					return pos;
			++pos;
			++i;
		}

		return -1;
	}


	//! Finds first position of a character not in a given list.
	//! \param c A list of characters to NOT find. For example if the method should find the first occurrence of a character not 'a' or 'b', this parameter should be "ab".
	//! \param count The amount of characters in the list. Usually, this should be strlen(c).
	//! \return Position where the character has been found, or -1 if not found.
	s32 findFirstCharNotInList(const uchar32_t* const c, u32 count=1) const
	{
		if (!c || !count)
			return -1;

		const_iterator i(*this, 0);

		s32 pos = 0;
		while (!i.atEnd())
		{
			uchar32_t t = *i;
			u32 j;
			for (j=0; j<count; ++j)
				if (t == c[j])
					break;

			if (j==count)
				return pos;
			++pos;
			++i;
		}

		return -1;
	}

	//! Finds last position of a character not in a given list.
	//! \param c A list of characters to NOT find. For example if the method should find the first occurrence of a character not 'a' or 'b', this parameter should be "ab".
	//! \param count The amount of characters in the list. Usually, this should be strlen(c).
	//! \return Position where the character has been found, or -1 if not found.
	s32 findLastCharNotInList(const uchar32_t* const c, u32 count=1) const
	{
		if (!c || !count)
			return -1;

		const_iterator i(end());
		--i;

		s32 pos = size() - 1;
		while (!i.atStart())
		{
			uchar32_t t = *i;
			u32 j;
			for (j=0; j<count; ++j)
				if (t == c[j])
					break;

			if (j==count)
				return pos;
			--pos;
			--i;
		}

		return -1;
	}

	//! Finds next occurrence of character.
	//! \param c The character to search for.
	//! \param startPos The position in the string to start searching.
	//! \return Position where the character has been found, or -1 if not found.
	s32 findNext(uchar32_t c, u32 startPos) const
	{
		const_iterator i(*this, startPos);

		s32 pos = startPos;
		while (!i.atEnd())
		{
			uchar32_t t = *i;
			if (t == c)
				return pos;
			++pos;
			++i;
		}

		return -1;
	}


	//! Finds last occurrence of character.
	//! \param c The character to search for.
	//! \param start The start position of the reverse search ( default = -1, on end ).
	//! \return Position where the character has been found, or -1 if not found.
	s32 findLast(uchar32_t c, s32 start = -1) const
	{
		u32 s = size();
		start = core::clamp ( start < 0 ? (s32)s : start, 0, (s32)s ) - 1;

		const_iterator i(*this, start);
		u32 pos = start;
		while (!i.atStart())
		{
			uchar32_t t = *i;
			if (t == c)
				return pos;
			--pos;
			--i;
		}

		return -1;
	}

	//! Finds last occurrence of a character in a list.
	//! \param c A list of strings to find. For example if the method should find the last occurrence of 'a' or 'b', this parameter should be "ab".
	//! \param count The amount of characters in the list. Usually, this should be strlen(c).
	//! \return Position where one of the characters has been found, or -1 if not found.
	s32 findLastChar(const uchar32_t* const c, u32 count=1) const
	{
		if (!c || !count)
			return -1;

		const_iterator i(end());
		--i;

		s32 pos = size();
		while (!i.atStart())
		{
			uchar32_t t = *i;
			for (u32 j=0; j<count; ++j)
				if (t == c[j])
					return pos;
			--pos;
			--i;
		}

		return -1;
	}


	//! Finds another ustring16 in this ustring16.
	//! \param str The string to find.
	//! \param start The start position of the search.
	//! \return Positions where the ustring16 has been found, or -1 if not found.
	s32 find(const ustring16<TAlloc>& str, const u32 start = 0) const
	{
		u32 my_size = size();
		u32 their_size = str.size();

		if (their_size == 0 || my_size - start < their_size)
			return -1;

		const_iterator i(*this, start);

		s32 pos = start;
		while (!i.atEnd())
		{
			const_iterator i2(i);
			const_iterator j(str, 0);
			uchar32_t t1 = (uchar32_t)*i2;
			uchar32_t t2 = (uchar32_t)*j;
			while (t1 == t2)
			{
				++i2;
				++j;
				if (j.atEnd())
					return pos;
				t1 = (uchar32_t)*i2;
				t2 = (uchar32_t)*j;
			}
			++i;
			++pos;
		}

		return -1;
	}


	//! Finds another ustring16 in this ustring16.
	//! \param str The string to find.
	//! \param start The start position of the search.
	//! \return Positions where the string has been found, or -1 if not found.
	s32 find_raw(const ustring16<TAlloc>& str, const u32 start = 0) const
	{
		const uchar16_t* data = str.c_str();
		if (data && *data)
		{
			u32 len = 0;

			while (data[len])
				++len;

			if (len > used)
				return -1;

			for (u32 i=start; i<=used-len; ++i)
			{
				u32 j=0;

				while(data[j] && array[i+j] == data[j])
					++j;

				if (!data[j])
					return i;
			}
		}

		return -1;
	}


	//! Returns a substring.
	//! \param begin: Start of substring.
	//! \param length: Length of substring.
	//! \return A reference to our current string.
	ustring16<TAlloc> subString(u32 begin, s32 length) const
	{
		u32 len = size();
		// if start after ustring16
		// or no proper substring length
		if ((length <= 0) || (begin>=len))
			return ustring16<TAlloc>("");
		// clamp length to maximal value
		if ((length+begin) > len)
			length = len-begin;

		ustring16<TAlloc> o;
		o.reserve((length+1) * 2);

		const_iterator i(*this, begin);
		while (!i.atEnd() && length)
		{
			o.append(*i);
			++i;
			--length;
		}

		return o;
	}


	//! Appends a character to this ustring16.
	//! \param c Character to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& operator += (char c)
	{
		append((uchar32_t)c);
		return *this;
	}


	//! Appends a character to this ustring16.
	//! \param c Character to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& operator += (uchar32_t c)
	{
		append(c);
		return *this;
	}


	//! Appends a number to this ustring16.
	//! \param c Number to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& operator += (short c)
	{
		append(core::stringc(c));
		return *this;
	}


	//! Appends a number to this ustring16.
	//! \param c Number to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& operator += (unsigned short c)
	{
		append(core::stringc(c));
		return *this;
	}


#ifdef USTRING_CPP0X_NEWLITERALS
	//! Appends a number to this ustring16.
	//! \param c Number to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& operator += (int c)
	{
		append(core::stringc(c));
		return *this;
	}


	//! Appends a number to this ustring16.
	//! \param c Number to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& operator += (unsigned int c)
	{
		append(core::stringc(c));
		return *this;
	}
#endif


	//! Appends a number to this ustring16.
	//! \param c Number to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& operator += (long c)
	{
		append(core::stringc(c));
		return *this;
	}


	//! Appends a number to this ustring16.
	//! \param c Number to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& operator += (unsigned long c)
	{
		append(core::stringc(c));
		return *this;
	}


	//! Appends a number to this ustring16.
	//! \param c Number to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& operator += (double c)
	{
		append(core::stringc(c));
		return *this;
	}


	//! Appends a char ustring16 to this ustring16.
	//! \param c Char ustring16 to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& operator += (const uchar16_t* const c)
	{
		append(c);
		return *this;
	}


	//! Appends a ustring16 to this ustring16.
	//! \param other ustring16 to append.
	//! \return A reference to our current string.
	ustring16<TAlloc>& operator += (const ustring16<TAlloc>& other)
	{
		append(other);
		return *this;
	}


	//! Replaces all characters of a given type with another one.
	//! \param toReplace Character to replace.
	//! \param replaceWith Character replacing the old one.
	//! \return A reference to our current string.
	ustring16<TAlloc>& replace(uchar32_t toReplace, uchar32_t replaceWith)
	{
		iterator i(*this, 0);
		while (!i.atEnd())
		{
			typename ustring16<TAlloc>::access a = *i;
			if ((uchar32_t)a == toReplace)
				a = replaceWith;
			++i;
		}
		return *this;
	}


	//! Replaces all instances of a string with another one.
	//! \param toReplace The string to replace.
	//! \param replaceWith The string replacing the old one.
	//! \return A reference to our current string.
	ustring16<TAlloc>& replace(const ustring16<TAlloc>& toReplace, const ustring16<TAlloc>& replaceWith)
	{
		if (toReplace.size() == 0)
			return *this;

		const uchar16_t* other = toReplace.c_str();
		const uchar16_t* replace = replaceWith.c_str();
		const u32 other_size = toReplace.size_raw();
		const u32 replace_size = replaceWith.size_raw();

		// Determine the delta.  The algorithm will change depending on the delta.
		s32 delta = replace_size - other_size;

		// A character for character replace.  The string will not shrink or grow.
		if (delta == 0)
		{
			s32 pos = 0;
			while ((pos = find_raw(other, pos)) != -1)
			{
				for (u32 i = 0; i < replace_size; ++i)
					array[pos + i] = replace[i];
				++pos;
			}
			return *this;
		}

		// We are going to be removing some characters.  The string will shrink.
		if (delta < 0)
		{
			u32 i = 0;
			for (u32 pos = 0; pos <= used; ++i, ++pos)
			{
				// Is this potentially a match?
				if (array[pos] == *other)
				{
					// Check to see if we have a match.
					u32 j;
					for (j = 0; j < other_size; ++j)
					{
						if (array[pos + j] != other[j])
							break;
					}

					// If we have a match, replace characters.
					if (j == other_size)
					{
						for (j = 0; j < replace_size; ++j)
							array[i + j] = replace[j];
						i += replace_size - 1;
						pos += other_size - 1;
						continue;
					}
				}

				// No match found, just copy characters.
				array[i - 1] = array[pos];
			}
			array[i] = 0;
			used = i;

			return *this;
		}

		// We are going to be adding characters, so the string size will increase.
		// Count the number of times toReplace exists in the string so we can allocate the new size.
		u32 find_count = 0;
		s32 pos = 0;
		while ((pos = find_raw(other, pos)) != -1)
		{
			++find_count;
			++pos;
		}

		// Re-allocate the string now, if needed.
		u32 len = delta * find_count;
		if (used + len >= allocated)
			reallocate(used + len);

		// Start replacing.
		pos = 0;
		while ((pos = find_raw(other, pos)) != -1)
		{
			uchar16_t* start = array + pos + other_size - 1;
			uchar16_t* ptr   = array + used;
			uchar16_t* end   = array + used + delta;

			// Shift characters to make room for the string.
			while (ptr != start)
			{
				*end = *ptr;
				--ptr;
				--end;
			}

			// Add the new string now.
			for (u32 i = 0; i < replace_size; ++i)
				array[pos + i] = replace[i];

			pos += replace_size;
			used += delta;
		}

		// Terminate the string and return ourself.
		array[used] = 0;
		return *this;
	}


	//! Removes characters from a ustring16..
	//! \param c The character to remove.
	//! \return A reference to our current string.
	ustring16<TAlloc>& remove(uchar32_t c)
	{
		u32 pos = 0;
		u32 found = 0;
ofs	hex dump	ascii
0000	89 50 4e 47 0d 0a 1a 0a 00 00 00 0d 49 48 44 52 00 00 00 40 00 00 00 40 08 06 00 00 00 aa 69 71	.PNG........IHDR...@...@......iq
0020	de 00 00 00 06 62 4b 47 44 00 ff 00 03 00 00 31 61 c2 aa 00 00 00 09 70 48 59 73 00 00 0b 13 00	.....bKGD......1a......pHYs.....
0040	00 0b 13 01 00 9a 9c 18 00 00 00 07 74 49 4d 45 07 e1 01 0c 12 21 30 d3 9e a6 de 00 00 11 73 49	............tIME.....!0.......sI
0060	44 41 54 78 da e5 9b d9 8f 9c c7 71 c0 7f dd fd 5d 73 ec 31 7b 52 4b ae 48 2e cf 10 b6 23 2b b6	DATx.......q....]s.1{RK.H....#+.
0080	68 0b b6 03 3b 0f 8a 02 5a 46 80 24 cf 36 f2 9a ff c4 4f c9 3f e0 47 07 4e 82 04 50 10 c7 0f 0e	h...;...ZF.$.6....O.?.G.N..P....
00a0	1c 03 16 62 21 96 0f 1d a4 44 8a e4 de d7 2c 77 e7 fc ee ee 3c f4 cc ce cc ee 0c 77 97 12 4c 25	...b!....D....,w....<......w..L%
00c0	29 60 80 fa ba be ea af ab ba aa ba ba ba 47 70 02 dc 59 2c 99 2c 89 09 94 c4 75 04 64 29 9e ef	)`............Gp..Y,.,....u.d)..
00e0	21 85 41 39 01 46 1b c2 24 24 c1 90 6b 70 1d 83 04 da a9 83 e7 0a dc 1c 52 91 0d a5 05 e4 44 7a	!.A9.F..$$..kp..........R.....Dz
0100	38 9f 43 7a 22 fe 2f 8f 23 f1 b4 b1 7f f7 8b 98 e5 1d b8 38 0b 3f ff 1d bc 7c 03 92 0c ee af c2	8.Cz"./.#..........8.?...\|......
0120	ed 9b f6 1d e7 24 05 78 9e c3 78 00 79 a2 51 8e 83 94 10 78 12 23 1d 5c 63 f0 c6 cb 88 a6 26 8b	.....$.x..x.y.Q....x.#.\c.....&.
0140	22 1c 05 79 0a b9 04 bf 60 3b 9f ad 54 d8 da df 1d 4a 0b a4 4b 92 24 43 69 59 72 32 fe 69 c0 89	"..y....`;..T....J..K.$CiYr2.i..
0160	fd 84 51 82 08 34 42 e4 24 3a 45 61 68 b5 32 84 93 83 14 94 db 21 8d 76 04 1a 72 05 42 82 12 90	..Q..4B.$:Eah.2......!.v..r.B...
0180	e7 90 1b 68 86 2d 4c 36 9c d6 10 8c a4 39 a7 c0 4f 03 17 67 61 79 f7 13 28 40 49 49 ab 99 0e b8	...h.-L6.....9..O..gay..(@II....
01a0	40 f1 d0 05 7c 4c 92 e3 22 48 a4 21 cf c1 75 c0 00 51 02 9e 0b 61 2b c1 48 86 d2 02 93 12 8d a0	@...\|L.."H.!..u..Q...a+.H.......
01c0	49 d1 c3 d3 0c 4a 45 48 73 88 e2 1e 7e 16 f8 58 03 77 2d 7e 2b e8 b5 cb d3 b8 c0 d4 b8 8f ef 2a	I....JEHs...~..X.w-~+..........*
01e0	5c d7 c3 f7 5c 0a 9e c4 f3 7d 02 69 98 98 2c 53 2c fa 48 09 be db 99 51 6d cd d4 75 60 76 a6 32	\...\....}.i..,S,.H....Qm..u`v.2
0200	92 16 78 ee 48 5a 3f ee bb bd f1 f4 e3 a7 85 ff 58 1f 7c fe 20 fa 5f e6 02 46 db 99 f7 24 e8 3e	..x.HZ?.........X.\|..._..F...$.>
0220	fc d3 80 13 bb 99 1a ef cd 0e 39 e4 19 08 05 be d0 8c f9 9a a8 d5 c0 97 56 00 47 80 06 a2 0c 3c	..........9.............V.G....<
0240	c7 b6 8d 15 4a 23 69 ea 29 7c fd 78 51 49 7c 24 9e 92 03 f8 ef 45 01 4f 1a bd 41 26 da fa a9 94	....J#i.)\|.xQI\|$.....E.O..A&....
0260	10 e6 86 27 0d 4d 26 0c 19 bd 88 d4 35 e9 43 fe 56 3c 92 86 d0 23 69 03 b8 23 70 7d 70 d4 20 7e	...'.M&.....5.C.V<...#i..#p}p..~
0280	5a f8 de 4b 83 cf fd 31 e0 e4 d5 c4 58 35 19 63 7f 5a d8 25 4b 3a 0c 2c 5f ae 02 cf 83 56 cb 3e	Z..K...1....X5.c.Z.%K:.,_....V.>
02a0	77 cd d4 09 ec 3b c3 68 19 b6 8f 61 b4 7e 53 6f e4 02 e5 0a 74 3e 88 9f 05 ae c8 5e 1e c0 ea 19	w....;.h...a.~So....t>.....^....
02c0	14 30 35 0e 61 1b b4 01 df 03 65 2c 7e d4 77 25 92 38 84 82 03 42 18 a2 5c e2 2a 81 c8 47 d3 52	.05.a.....e,~.w%.8...B..\.*..G.R
02e0	34 d2 0c a7 29 21 0f 71 57 81 23 04 b9 92 28 a7 87 ff 5e 5c a0 5a ef b9 40 37 06 64 f9 71 df 15	4...)!.qW.#...(...^\.Z..@7.d.q..
0300	18 5c 4f 20 94 19 30 53 4f 8d a6 29 31 9a 36 f0 9e 86 24 13 88 dc 0c e0 4f 83 9f fc f8 5f 4f 95	.\O...0SO..)1.6...$.....O...._O.
0320	29 38 fd 2f be f6 fa 9d 63 a9 e5 94 97 e1 05 82 b0 0d be 84 48 7a f8 52 e0 98 b4 d3 ae 91 2e 98	)8./....c...........Hz.R........
0340	dc fa 8b 41 d2 c8 38 34 d3 6a 3d 24 d0 c3 69 e4 19 c6 88 a1 b4 7e 53 77 1c 81 c6 45 e8 14 47 f6	...A..84.j=$..i......~Sw...E..G.
0360	f0 4f 2a fc a1 0b b4 5a 6d 5c d7 39 c6 f8 da eb 77 44 98 1b 9a 0d 73 98 ab 27 a9 06 57 90 ea c1	.O*....Zm\.9....wD....s..'..W...
0380	76 4f d9 dc 20 57 0e 4e 1a 1f 9a 69 d2 4c 28 7a 62 28 2d d2 86 40 0e e7 eb 37 f5 d8 e4 38 22 e9	vO...W.N...i.L(zb(-..@...7...8".
03a0	e0 fa 10 1f 06 ff fc 4f 3f 32 71 1c e3 fb fe e9 5d e0 57 ef bc c3 fd fb 0f 86 6a 72 54 a2 72 b4	.......O?2q.....].W.......jrT.r.
03c0	5d 0a 28 b8 1a 15 46 03 66 ea 17 46 d3 4c 36 9a 76 1a 7c d8 78 df 7f ff 03 7e f7 bb 77 cf 16 03	].(...F.f..F.L6.v.\|.x....~..w...
03e0	8c 31 ac ac ae 91 a6 83 66 95 24 e9 a1 80 5d 9f 17 9d 38 70 b4 3d 33 10 c7 0a a5 24 8e 14 28 e5	.1......f.$...]...8p.=3....$..(.
0400	22 b0 ef 8f a4 c9 d1 b4 d3 e0 ff fe 6f 6f 9a 7e e1 9b cd 26 ef 7f 70 97 24 4d cf be 19 8a 93 98	"...........oo.~...&..p.$M......
0420	7a a3 c9 f4 54 e5 90 b8 b1 b9 c1 d2 5f fd 0d 53 53 53 bc f3 ce af f9 f2 ed 57 c8 f3 9c e7 05 52	z...T......._..SSS.......W.....R
0440	2a de 7a eb 2d 5e 79 e5 15 76 77 77 69 b7 c3 01 9f 5f 5b 5f a7 dd 6e 23 e5 e8 5d 72 ae a1 18 d8	*.z.-^y..vwwi...._[_..n#..]r....
0460	40 ee a8 3e 05 2c 5d 5e e2 e0 e0 80 52 b1 40 92 24 20 04 db db 3b 7c e1 f3 5f e0 c2 e2 79 b4 36	@..>.,]^....R.@.$....;\|.._...y.6
0480	7c e5 2b b7 91 52 3e 37 05 e4 b9 46 eb 9c af 7e f5 ab 3c 7c f8 90 9d dd 5d fe e1 47 3f 34 f5 7a	\|.+..R>7...F...~..<\|....]..G?4.z
04a0	1d 63 0c f5 7a 83 db b7 6f 13 c7 d1 e8 b4 46 43 d1 87 4c f7 29 c0 68 cd f9 f3 0b 3c 7a f4 98 8d	.c..z...o.....FC..L.).h....<z...
04c0	8d 0d 1c c7 45 29 c5 ca ca 2a 37 6f de 44 0a 49 96 67 08 04 cf 13 84 80 34 cd 90 42 50 a9 54 78	....E)...*7o.D.I.g......4..BP.Tx
04e0	f3 cd 37 b9 74 e9 92 4d d0 74 8e d6 86 6b d7 2e f2 e0 fe fd a7 58 11 b4 22 70 64 9f 0b 18 40 29	..7.t..M.t...k.......X.."pd...@)
0500	85 e3 38 5c b9 72 95 f1 f1 31 db 28 40 88 e7 2b f4 a8 e4 54 08 c1 e2 e2 22 b7 6e dd 42 08 41 bb	..8\.r...1.(@..+...T....".n.B.A.
0520	dd 66 79 79 e5 44 17 95 12 c2 b8 97 4a 3b 58 39 09 c3 90 fd fd 7d 36 36 d6 11 42 20 a5 64 7f 7f	.fyy.D......J;X9.....}66..B..d..
0540	9f a5 4b 97 40 80 14 c2 4e c1 73 b4 02 81 1d 97 10 90 65 19 8f 1f 2f d3 68 34 d0 5a 23 84 20 0c	..K.@...N.s.......e.../.h4.Z#...
0560	23 26 26 c6 cf 5e 11 92 4a b1 bc bc 82 eb 28 be f9 fa 9f 1e 12 3f fa e8 3e 6b eb 1b 94 c7 c6 30	#&&..^..J.....(......?..>k.....0
0580	c6 50 ab d5 70 94 7a 6e 0a c8 b2 8c 34 4d a8 d5 ea 2c 2f af 70 fb f6 97 b9 b2 b4 74 48 ff c5 2f	.P..p.zn....4M...,/.p......tH../
05a0	de e2 97 bf fc 25 57 af 5e 39 9b 02 b4 d6 bc f7 de bb bc f1 c6 b7 07 88 13 13 13 7c 70 f7 1e 5b	.....%W.^9.................\|p..[
05c0	5b 5b ac af af 51 2a 95 c9 f3 ec 39 ae 02 92 df fc e6 b7 b4 db 6d 1a 8d 06 df f8 c6 d7 07 e8 57	[[...Q*....9.........m.........W
05e0	af 5e e5 dd f7 de 3f 53 45 c8 e9 e6 01 33 33 b3 cc 4c 4f 0f 30 cd cf cf b1 f9 e3 1f 80 e3 a2 72	.^....?SE....33..LO.0..........r
0600	c3 7f bd fd 63 a4 92 a4 79 72 d8 86 01 a9 24 9e c9 f0 c7 8a 78 26 23 a6 44 14 b7 20 0d 7b e9 b2	....c...yr....$.....x&#.D....{..
0620	80 08 17 57 0a 5c d7 c3 24 ad a1 b4 c0 15 64 49 32 94 a6 74 82 c0 e5 f1 7b 3f e5 7b 7f f7 43 94	...W.\..$.....dI2..t....{?.{..C.
0640	52 bc f6 fa 1d d1 5d 06 67 67 67 a8 54 2a e8 5c 0f c8 f1 83 df 1c af 08 7d af 5f 01 e5 52 89 d9	R.....].ggg.T*.\........}._..R..
0660	99 19 a4 94 87 fb 81 6e a7 99 76 c9 9a 7d 65 f1 28 22 53 85 63 6d f8 1e 69 b3 85 76 02 8c 6e 91	.......n..v..}e.("S.cm..i..v..n.
0680	77 4a e5 c3 d2 68 da 11 a9 18 4e 53 b1 2d 95 0f a3 19 cc 21 fe 67 77 be 23 fa 53 76 9b b5 4a 6e	wJ...h....NS.-.....!.gw.#.Sv..Jn
06a0	dc b8 7e 2c a1 3b d1 05 5e 7e f9 8b 68 ad 87 6e 86 1c 99 e2 94 7d 54 6e d0 06 64 e0 e2 09 f5 dc	..~,.;..^~..h..n.....}Tn..d.....
06c0	4b e5 47 a1 ab 84 2f 7c fe 73 64 d9 e9 93 35 49 67 09 bc f3 c6 9f 8b a3 1d 76 2d 20 6a c6 e4 49	K.G.../\|.sd...5Ig........v-.j..I
06e0	86 34 39 44 6d c2 28 21 d6 19 b9 48 09 75 48 44 c6 5e 2b 66 3f 8c d9 49 12 0e da 21 b5 76 34 32	.49Dm.(!...H.uHD.^+f?..I...!.v42
0700	8d 3e ac 13 0e a1 35 52 46 d2 fa 71 46 28 41 4a 89 e7 0d 56 4e bf 75 7e 74 45 48 8e da 06 3f ad	.>....5RF..qF(AJ...VN.u~tEH...?.
0720	2a fc 59 a8 13 8e 82 51 b2 5c 91 f0 97 7f 00 df b9 76 c4 02 9e 26 fc 6b af df 11 c3 66 fb b3 50	*.Y....Q.\.......v...&.k....f..P
0740	27 7c 1a 1c 95 e9 e2 2c ec ea 11 2e 60 14 e6 69 bf 61 b3 7d 58 27 14 9d 3a 21 9d 3a e1 91 2d b2	'\|.....,....`..i.a.}X'..:!.:..-.
0760	a3 c0 f7 7b cf cd d8 e6 e2 4e 30 9a 96 3d 85 af 1f 3f ab 12 3e d5 aa 70 bf 52 7c af 63 96 ea b8	...{.....N0..=...?..>..p.R\|.c...
0780	ef da 5a a0 a4 e0 a8 81 72 76 af 4e 38 84 f6 14 be 4f 52 12 9f 95 b0 56 7d 06 05 0c 9b ed cf 42	..Z.....rv.N8....OR....V}......B
07a0	9d f0 d3 82 67 aa 0a 97 c4 f3 af 13 76 e1 fb df ff 5b 13 45 75 00 82 20 a0 54 2a d1 6a b5 98 9e	....g.......v....[.Eu....T*.j...
07c0	9e a6 5e af 93 a6 29 e7 ce 2d f0 b9 ed 4d 92 24 21 8e 63 be 56 2a 91 24 09 9e 5f 78 b6 aa f0 d1	..^...)..-...M.$!.c.V*.$.._x....
07e0	60 97 a4 9a 54 eb 63 ed 52 09 7c df c7 29 16 09 7c 45 41 09 1c 57 91 a4 7a 24 2d 13 a3 f9 fa f1	`...T.c.R.\|..)..\|EA..W..z$-.....
0800	2e 94 4a 2e 41 10 d0 6c b6 89 a2 94 b7 df 7e 9b 73 e7 16 78 f8 f0 21 69 9a 12 04 01 db 3b bb 34	..J.A..l......~.s..x..!i.....;.4
0820	1a 21 77 ef de a5 54 2a f1 c2 0b e7 f1 3c 8f 3c 4b 4e 61 01 43 aa c2 92 74 68 a2 92 67 83 87 25	.!w...T*.....<.<KNa.C...th..g..%
0840	d2 b1 f5 be b0 15 81 14 24 46 e0 88 4e 9d 50 0f a7 99 0c a4 37 9c 26 e1 10 ef 1d 5f 3b 44 51 44	........$F..N.P.....7.&...._;DQD
0860	bb dd a4 5e 3f 00 6d a8 d5 f6 99 98 98 a4 50 08 3a 3b dc 0d d2 34 45 3a 0a 63 0c 9b 5b db ec ec	...^?.m.......P.:;...4E:.c..[...
0880	ec 32 3f 3f 77 8a c3 d1 21 55 61 5f 0c 3f d0 3c 7a 58 d2 ab f7 d9 9d 74 b7 9c 2d 72 7b 2a 34 94	.2??w...!Ua_.?.<zX.....t..-r{*4.
08a0	26 47 f3 0d 2b 89 67 71 c4 d4 d4 14 97 2e 2d b1 b2 f2 98 52 a9 44 18 86 34 db 4d ee df ff 88 b9	&G..+.gq......-....R.D..4.M.....
08c0	b9 39 6e dd ba c5 e4 e4 14 5b 5b 1b d4 eb 75 aa d5 2a 69 9c 50 28 04 27 2b 40 4a 8e cd b6 48 ac	.9n......[[...u..*i.P(.'+@J...H.
08e0	80 a9 19 3c bb 47 1e 6d 17 d4 b2 04 93 65 28 09 a9 8e c8 73 28 15 1d d2 5c 92 64 11 9e 07 7b 4d	...<.G.m.....e(....s(...\.d...{M
0900	83 94 31 4a da 00 da 4a 72 70 62 d2 5c 74 78 63 52 6d 3a bc 19 a9 ee ad 70 b5 5a 0d 70 d8 dc dc	..1J...Jrpb.\txcRm:.....p.Z.p...
0920	e4 e0 e0 80 c5 c5 45 84 70 d8 5c df 25 cf 73 0a 85 02 cd 66 93 46 a3 41 14 45 34 1a 0d 16 16 16	......E.p.\.%.s....f.F.A.E4.....
0940	18 1b 1b 23 f0 4e a1 80 61 c7 d7 03 ca 91 23 94 76 9a 76 a1 88 32 49 c1 49 88 f5 b3 f5 e9 fb 3e	...#.N..a.....#.v.v..2I.I......>
0960	1f 7f fc 31 61 18 72 f1 e2 45 a6 66 a6 d8 da d8 e2 da b5 cb e4 79 ce f9 f3 8b ec ec 6c 71 ef de	...1a.r..E.f.........y......lq..
0980	3d 84 10 64 59 c6 d2 d2 12 51 14 91 65 d9 c9 0a 10 f2 f8 6c 6b 46 1c 84 aa b3 b5 bb 9e 04 a5 88	=..dY....Q..e......lkF..........
09a0	f3 b3 f3 76 61 67 67 8f af 7d ed 1b 3c 7a f4 90 42 21 20 6c 85 04 c1 38 a5 92 4b ab d5 62 6f 6f	...vagg..}..<z..B!.l...8..K..boo
09c0	17 ad 35 17 2f 5e 24 cb 32 26 27 27 71 fc 80 c9 20 60 6b 7b fb f4 77 8d fa 67 60 d4 61 27 fa 6c	..5./^$.2&''q....`k{..w..g`.a'.l
09e0	ed ca 48 50 2e ae 1b a3 53 73 b6 3e bb 0a d8 de 62 63 63 8a 72 b9 44 a5 52 61 65 65 85 e5 e5 65	..HP....Ss.>....bcc.r.D.Raee...e
0a00	6e dc b8 41 b9 5c 26 0c 43 1a 8d 06 f5 7a 9d f3 e7 ed ae a8 55 af 01 b0 b6 ba 7e f2 32 38 2c 2d	n..A.\&.C....z......U.....~.28,-
0a20	1d 95 a8 9c b5 3d 27 47 e7 09 cd 76 7e 66 de 2e 7c e9 cb 7f 84 94 92 5a ad 46 ad 56 63 75 75 15	.....='G...v~f..\|......Z.F.Vcuu.
0a40	df f7 91 52 51 af d7 f9 f0 c3 0f 69 b7 db ec ed ed 31 31 31 c1 de de 3e ad 56 84 eb ba 5c bf 79	...RQ......i.....111...>.V...\.y
0a60	f5 14 41 70 c8 6c 9b 5c 0f 4d 54 46 25 3e a3 da c3 3c 41 67 2e 71 ae 71 a5 3a 13 ef e1 81 4e 6c	..Ap.l.\.MTF%>...<Ag.q.q.:....Nl
0a80	93 9b b9 b9 39 b4 d6 5c ba 74 89 52 a9 c4 e4 e4 24 bb bb bb 5c b9 72 05 a5 14 93 93 93 64 06 84	....9..\.t.R....$...\.r......d..
0aa0	52 34 6a fb 5c b9 b2 c4 ce ce d6 29 62 00 06 d7 93 08 a3 f1 a5 20 77 40 66 c3 0f 3b 33 93 9d a9	R4j.\......)b.........w@f..;3...
0ac0	dd 2f 8e a1 80 b1 82 47 18 86 67 e2 ed ad 02 4d b6 b7 d7 29 96 8b 44 ed 88 38 4e f9 f0 de 3b 5c	./.....G..g....M...)..D..8N...;\
0ae0	5e ba cc b5 6b 37 a8 56 77 c8 b2 8c b9 b9 39 6a b5 1a 7b bb db d4 6a 75 b6 36 37 f0 82 c2 29 56	^...k7.Vw.....9j..{...ju.67...)V
0b00	81 21 33 d0 3d d0 3c 96 a8 9c b1 3d 4f 23 72 47 a1 c9 cf cc 7b 98 a9 3e d9 26 0c 43 c2 56 c8 da	.!3.=.<....=O#rG....{..>.&.C.V..
0b20	da 1a b5 5a 83 f1 f1 71 5c d7 65 75 75 99 d5 d5 55 16 16 16 a8 ed ef 13 14 8b 5c bb 76 8d a8 1d	...Z...q\.euu...U.........\.v...
0b40	a2 1c c5 af df f9 ef 53 b8 80 3a 3e db 61 3e 3c 51 19 95 c0 8c 6a 97 8e 42 fa 01 42 e6 44 f5 d6	.......S..:>.a><Q....j..B..B.D..
0b60	99 78 bb f0 f2 4b 5f 3c f4 ff 0b 17 2e f0 ea ab 97 58 5d 5d 46 08 c1 83 07 0f 28 16 27 90 52 32	.x...K_<.........X]]F.....(.'.R2
0b80	3e 39 8b 10 19 71 1c 53 28 15 a9 56 9f 70 e3 c6 8d 93 83 e0 b0 e3 6b 47 80 ef e7 e4 b9 26 d3 86	>9...q.S(..V.p........kG.....&..
0ba0	3c 4f 31 70 e6 76 9d e5 64 71 44 1c 46 67 e6 ed 42 50 0c a8 d5 6a 54 9f 54 f1 3c 9f cd cd 75 7c	<O1p.v..dqD.Fg..BP...jT.T.<...u\|
0bc0	df a7 54 2a 71 f3 e6 4d 2e 5c 98 c7 18 83 eb 29 84 10 34 9b 09 f5 7a 8b 95 95 c7 4c 4d cc 9c 6c	..T*q..M.\.....)..4...z....LM..l
0be0	01 c3 66 20 49 93 cf 8c 05 6c 6d 6c f1 e4 49 8d 56 a3 85 f0 21 aa c5 4c 4c 4c 50 ad 56 d1 5a 93	..f.I....lml..I.V...!..LLLP.V.Z.
0c00	e7 39 93 9d 92 ff cf 7f fe 33 7c df a7 d1 68 10 c7 31 51 96 9e ac 80 bf 7f 94 08 48 fa 5a 5a dd	.9.......3\|...h..1Q........H.ZZ.
0c20	db 03 43 da 9e a5 bd f9 09 78 21 cf 73 ae 5e bd cc 58 b9 cc fe c1 01 41 30 ce bd 7b f7 30 69 0a	..C......x!.s.^..X.....A0..{.0i.
0c40	8e 43 ab d5 e2 fa f5 eb ec ee 6d 73 ee dc 39 ca e5 32 0b 0b 17 d8 dd dd c6 e8 84 ff f7 70 62 6d	.C........ms..9..2...........pbm
0c60	e5 bb 2f f1 cd fa 0e 7f fd 27 37 e1 83 2a 8f ff af 29 40 00 fc b1 8f d9 8f 87 bf 30 33 0d 6b 4f	../......'7..*...)@........03.kO
0c80	a0 52 b0 95 a1 51 a0 b1 97 25 9f e3 05 92 53 1f ad cf 15 e0 a7 a1 95 dd 01 78 37 86 2b d3 d0 6c	.R...Q...%....S..........x7.+..l
0ca0	d9 ba 7c c1 b7 57 d5 01 64 01 84 0b 6d 01 94 86 77 ea 2a 7b e9 a0 52 81 83 e6 91 0f 1a 7b a9 2a	..\|..W..d...m...w.{..R......{.
0cc0	fb 84 8a 29 fa d0 68 83 e3 d8 3e 9f ed 70 15 d6 1a b0 1b 0e a9 09 9e ab 40 18 d8 7c 7f 61 c6 0a	...)..h...>..p..........@..\|.a..
0ce0	d5 85 72 00 13 a5 ce f5 00 ac 90 dd e7 2e fe 78 1b ce cf c0 d2 39 f8 78 13 5e 9c b3 42 d7 5a 30	..r............x.....9.x.^..B.Z0
0d00	3f 69 eb 05 ae 63 97 d5 a3 7d 3c d8 b0 ef 7b 4e 8f 36 59 ee 7d ff a0 09 e3 25 58 dd 81 c5 39 58	?i...c...}<...{N.6Y.}....%X...9X
0d20	d9 b6 7d bd 30 6d fb 3b 68 42 3b 86 f9 8a 9d c0 8d 3d 38 37 05 5b 4f 7a 6d dd 1b 26 53 3b 70 77	..}.0m.;hB;......=87.[Ozm..&S;pw
0d40	7d 48 55 58 49 6b 1f fb 0d 5b 77 bf b7 d2 fb 53 42 bf b0 5a 5b a1 ba 93 d0 c5 a5 b0 3f 21 a0 1d	}HUXIk...[w....SB..Z[.......?!..
0d60	da 36 47 c1 7a 15 92 dc 96 a4 c3 18 1e 6d da 02 eb 47 6b bd fe 43 9b e4 f1 68 d3 3e b7 23 2b 44	.6G.z........m...Gk..C...h.>.#+D
0d80	ae ed ac 1f 34 ed 56 7c ac 68 7d 36 d3 f6 fc a1 cb bf bc 6d c7 d5 1d 53 9a 75 57 08 06 72 06 d3	....4.V\|.h}6.......m...S.uW..r..
0da0	f7 3b a6 80 6e 8d 3f 4a 20 a7 73 a9 b8 a3 7d dd e1 a8 b7 6d e9 6b a2 d4 bb 27 92 e5 f6 e3 93 65	.;..n.?J..s...}....m.k...'.....e
0dc0	6b 62 60 2d 48 6b ab 54 df e9 b9 49 a6 7b 56 64 4c af df 85 69 db 2e 3b 97 b2 c7 8a bd c1 d7 5b	kb`-Hk.T...I.{VdL...i..;.......[
0de0	50 ee 54 9c 6a 6d 58 a9 5a be 72 d1 7e 03 20 f0 60 66 dc d6 2d c0 ce fe f6 13 98 99 e8 b5 75 03	P.T.jmX.Z.r.~...`f..-.........u.
0e00	9e 90 83 77 5c 04 c0 14 18 09 5c 9f 81 ed 7d b8 b2 00 8f b7 6c 2c 68 c7 30 3b 09 b5 a6 15 b6 18	...w\.....\...}.....l,h.0;......
0e20	d8 99 14 02 4a 41 c7 94 cb d0 0a 7b c2 cd 4e c0 e6 1e 04 3e 24 a9 fd db 8b a3 ac 52 7d c7 9a fa	....JA.....{..N....>$......R}...
0e40	6e 0d 26 c7 ec 6c 6b dd 13 5e 08 3b 28 a5 7a 7f 9b 29 17 61 2f 82 42 5f 5c 99 ab 58 45 ec d5 7a	n.&..lk..^.;(.z..).a/.B_\..XE..z
0e60	fc 87 95 e2 c0 5a e6 78 c9 f6 df 1f 03 36 db e0 02 db 1d d9 c5 5f cc 60 7e 56 85 2f 5d b4 83 7d	.....Z.x.....6......._.`~V./]..}
0e80	d2 80 8b 2f d8 4e 85 3d ca a7 14 74 4c c7 f4 84 04 d8 78 62 67 6a 71 f6 e8 91 3a ec 1e 40 a5 73	.../.N.=...tL.....xbgjq...:..@.s
0ea0	5d a7 19 42 b9 d0 e3 ef 9a 68 c1 b3 96 b1 5b b7 f4 7e 08 5c 6b da 69 67 1c 17 a6 ad 02 5d a7 97	]..B.....h....[..~.\k.ig.....]..
0ec0	a2 6b 63 bf af 94 9d 9c 92 6f 5d 67 7a c2 7e c3 75 8e df 32 5b dd 81 ad 03 78 75 06 fe b1 8a 70	.kc......o]gz.~.u..2[....xu....p
0ee0	b6 6a 50 c3 be 1c c5 56 2d ae ea 65 08 6e c9 9a 72 ad 65 4d b3 0b 6b 55 b8 34 37 22 b9 10 d6 7a	.jP....V-..e.n..r.eM..kU.47"...z
0f00	3c c7 f6 f7 24 01 6f ac 17 6b 76 f7 e1 fc ac 15 42 49 48 d3 1e 3d e9 9c 00 ef 37 ec ec 5f bb d0	<...$.o..kv.....BIH..=....7.._..
0f20	53 6a f5 00 a6 27 2d 5d 0a 58 de 82 17 66 ac fb 7a 8e 7d a7 bb 42 4c 8c 07 e4 49 64 65 11 b0 57	Sj...'-].X...f..z.}..BL...Ide..W
0f40	b7 ae e2 39 36 f7 dc 3a 80 6f cf 60 c4 92 c0 6c 19 98 f4 61 d6 81 30 b1 2f 36 fb 96 8a f9 8a 75	...96..:.o.`...l...a..0./6.....u
0f60	0d 57 c1 46 da 3b 6b 3b 0a e5 02 cc 4d 40 3b b1 83 37 c6 2e 8f be 6b cd 4f 0a eb 1e 0f 36 ec b2	.W.F.;k;....M@;..7....k.O....6..
0f80	d6 8d dc fb 0d 3b 83 e7 67 e1 de b6 f5 e1 c6 be ed af 19 5a 25 5d 7f 51 d1 68 03 3a c7 18 58 28	.....;..g..........Z%].Q.h.:..X(
0fa0	c3 af 1f c3 ad 6b f0 78 13 12 05 13 0e 48 e5 50 8b 0a bc 74 b3 c4 ce e6 96 bd 6d ae 6c d0 1d 2b	.....k.x.....H.P...t......m.l..+
0fc0	82 0c e0 fd 2a 2c 2a bb d1 72 5e fd 1c 7c b4 0e 63 65 b8 50 e9 99 ce d1 eb 81 f3 15 ab c9 e2 36	....,..r^..\|..ce.P...........6
0fe0	fc e1 92 35 35 29 ad 40 dd 65 a6 11 c2 58 41 72 77 59 e3 3a b0 38 0f b5 86 15 76 bc d4 7b af 5c	...55).@.e...XArwY.:.8....v..{.\
1000	84 f1 62 cf 8d 94 b2 8a 2f 17 e1 e5 17 6d f0 da 0c e0 dc 74 7f 25 58 33 59 82 9d 7d cb eb 79 20	..b...../....m.....t.%X3Y..}..y.
1020	5d 70 0d 4c 8f 59 cb b9 b8 e0 23 94 e2 57 f7 12 4c 26 18 2f 5a b7 10 c2 5a f0 f4 b8 dd dc 05 02	]p.L.Y....#..W..L&./Z...Z.......
1040	ae 2d c0 4f 7e db b9 fe a7 0d 94 7d a8 d6 ec 51 58 9a db d9 d9 ed 04 98 fd 26 1c b4 61 b2 64 7f	.-.O~......}...QX........&..a.d.
1060	a6 e3 7b 46 0f 2e 29 0a 78 6f d9 30 3d 5d a4 52 b6 1a 9e 2c 5b 8b fa 70 a5 97 25 1e 0a bf 67 73	..{F..).xo.0=].R...,[..p..%...gs
1080	84 82 07 b7 5e 84 99 31 6b 09 c6 d8 9c a2 3f 82 57 1b 06 21 04 9e 2b d9 d8 b3 63 be 3c 0f db 7b	....^..1k.....?.W..!..+...c.<..{
10a0	56 b9 05 df 5a 98 ef bb 04 81 22 4f 33 d6 76 ad 62 b2 dc 8e a1 32 6e 15 dd 8d fe 76 bb dd b7 7e	V...Z....."O3.v.b....2n....v...~
10c0	67 79 67 00 d8 0f 28 65 97 bd 4a 19 2a 63 96 e3 c5 79 cb 3c 5f e9 dc 30 95 bd de 7c 0f d2 4c 30	gyg...(e..J.*c...y.<_..0...\|..L0
10e0	3f 3f 46 d6 68 1f 26 3d 06 ab 54 23 fb ee 59 9a ce 9d 83 ce ba de 5d 9e 0e d7 e9 ce 98 96 77 ac	??F.h.&=..T#..Y.......].......w.
1100	0b 45 11 f8 4a 23 dc 19 0a 6e 15 85 3d aa db 4e 60 c1 ed 98 b7 89 c9 da 31 8b 15 fb 2f 13 29 6c	.E..J#...n..=..N`.......1.../.)l
1120	bf ba 33 ee ae 1b ca ce 7d 4f 09 88 af 9f c3 3c d8 82 17 26 ac 09 1a dd f9 17 67 67 80 dd 48 9a	..3.....}O.....<...&......gg..H.
1140	9f e2 52 c2 58 00 2b 3b 36 50 69 3d b8 2a b4 23 6b b6 fd eb 6f 96 db a0 94 64 56 d9 dd e4 e5 68	..R.X.+;6Pi=.*.#k...o....dV....h
1160	ba db 0d 8a 45 1f 82 72 99 17 75 93 4d 6c 92 d4 0c 6d d4 4f b2 c1 f4 bb 3f f2 f7 aa 5b b0 b1 63	....E..r..u.Ml...m.O....?...[..c
1180	e3 d3 e5 05 78 7b 1d c4 02 98 0d e0 12 b0 30 db 4b 4e 18 b2 ec 9d 04 9e 63 07 e4 7b cf 9e af 8f	....x{........0.KN......c..{....
11a0	fa 66 b7 bf ae c5 d2 b1 d2 b3 8c 51 0a 58 df 85 65 60 a1 3b 39 af ce c0 7f 56 61 69 11 16 a7 8f	.f.........Q.X..e`.;9....Vai....
11c0	e4 89 9f a2 00 9f 95 bd af e7 41 ba 6e f3 00 80 ff 01 ff 38 74 f5 88 f7 05 73 00 00 00 00 49 45	..........A.n......8t....s....IE
11e0	4e 44 ae 42 60 82	ND.B`.