return;

	}

	/* Determine a nice rounded size for the amount of allocated tiles */

	_animated_tile_allocated = 256;

static void Load_CHTS()

{

	Cheat *cht = (Cheat*)&_cheats;

	for (uint i = 0; i < count; i++) {

		cht[i].been_used = (SlReadByte() != 0);

		char buf2[lengthof(buf) + 32];

		snprintf(buf2, lengthof(buf2), "dbg: [%s] %s\n", dbg, buf);

	} else

#endif /* ENABLE_NETWORK */

	{

static Fio _fio;

/* Get current position in file */

{

	return _fio.pos + (_fio.buffer - _fio.buffer_end);

}

	return _fio.shortnames[slot];

}

{

	if (mode == SEEK_CUR) pos += FioGetPos();

	_fio.buffer = _fio.buffer_end = _fio.buffer_start + FIO_BUFFER_SIZE;

#include <string>

#include "core/enum_type.hpp"

const char *FioGetFilename(uint8 slot);

byte FioReadByte();

uint16 FioReadWord();

			break;

	}

	return pd(in_end,ii);

}

	*op++ = 0;

	*op++ = 0;

	return LZO_E_OK;

}

eof_found:

	assert(t == 1);

	return (ip == ip_end ? LZO_E_OK :

		   (ip < ip_end  ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));

	if (backspace) s = Utf8PrevChar(s);

	uint width = GetCharacterWidth(FS_NORMAL, c);

	tb->width  -= width;

bool InsertTextBufferChar(Textbuf *tb, WChar key)

{

	const byte charwidth = GetCharacterWidth(FS_NORMAL, key);

	if (tb->length < (tb->maxlength - len) && (tb->maxwidth == 0 || tb->width + charwidth <= tb->maxwidth)) {

		memmove(tb->buf + tb->caretpos + len, tb->buf + tb->caretpos, tb->length - tb->caretpos + 1);

		Utf8Encode(tb->buf + tb->caretpos, key);

			if (tb->caretpos < tb->length) {

				WChar c;

				tb->caretxoffs += GetCharacterWidth(FS_NORMAL, c);

				return true;

	return NULL;

}

{

	mc->memory = mem;

	mc->flags = flags;

	mc->frac_speed = (rate << 16) / _play_rate;

	/* adjust the magnitude to prevent overflow */

		size >>= 1;

		rate = (rate >> 1) + 1;

	}

}

void MxSetChannelVolume(MixerChannel *mc, uint left, uint right)

void MxMixSamples(void *buffer, uint samples);

MixerChannel *MxAllocateChannel();

void MxSetChannelVolume(MixerChannel *mc, uint left, uint right);

void MxActivateChannel(MixerChannel*);

	 *                 to place where parameter is to be stored. */

	/* Preload the next sprite */

	uint16 num = FioReadWord();

	uint8 type = FioReadByte();

struct GRFLabel {

	byte label;

	uint32 nfo_line;

	struct GRFLabel *next;

};

	if (CheckSavegameVersionOldStyle(5, 2)) {

		/* Version older than 5.2 did not have a ->next pointer. Convert them

		    (in the old days, the orderlist was 5000 items big) */

		uint i;

		if (CheckSavegameVersion(5)) {

uint16 _sl_version;       ///< the major savegame version identifier

byte   _sl_minor_version; ///< the minor savegame version, DO NOT USE!

/** The saveload struct, containing reader-writer functions, bufffer, version, etc. */

static struct {

	byte block_mode;                     ///< ???

	bool error;                          ///< did an error occur or not

	int array_index, last_array_index;   ///< in the case of an array, the current and last positions

	WriterProc *write_bytes;             ///< savegame writer function

	ReaderProc *read_bytes;              ///< savegame loader function

 */

static void SlReadFill()

{

	if (len == 0) SlError(STR_GAME_SAVELOAD_ERROR_BROKEN_SAVEGAME, "Unexpected end of chunk");

	_sl.bufp = _sl.buf;

	_sl.offs_base += len;

}

/** Return the size in bytes of a certain type of normal/atomic variable

 * as it appears in memory. See VarTypes

 * @param i Index being written

 */

{

	if (i >= (1 << 7)) {

		if (i >= (1 << 14)) {

			if (i >= (1 << 21)) {

				assert(i < (1 << 28));

				SlWriteByte((byte)(i >> 16));

			} else {

			}

			SlWriteByte((byte)(i >> 8));

		} else {

			SlWriteByte((byte)(0x80 | (i >> 8)));

		}

	}

}

/** Return how many bytes used to encode a gamma value */

{

	return 1 + (i >= (1 << 7)) + (i >= (1 << 14)) + (i >= (1 << 21));

}

static inline void SlWriteSparseIndex(uint index) {SlWriteSimpleGamma(index);}

static inline uint SlReadArrayLength() {return SlReadSimpleGamma();}

void SlSetArrayIndex(uint index)

{

	_sl.array_index = index;

}

/**

 * Iterate through the elements of an array and read the whole thing

			 * The lower 24 bits are normal

			 * The uppermost 4 bits are bits 24:27 */

			assert(length < (1 << 28));

			break;

		case CH_ARRAY:

			assert(_sl.last_array_index <= _sl.array_index);

		default: NOT_REACHED();

		} break;

	case NL_CALCLENGTH:

		break;

	}

}

}

/* Get the length of the current object */

/** Return a signed-long version of the value of a setting

 * @param ptr pointer to the variable

 * @param length The length of the array counted in elements

 * @param conv VarType type of the variable that is used in calculating the size

 */

{

	return SlCalcConvFileLen(conv) * length;

}

 * @param length The length of the array in elements

 * @param conv VarType type of the atomic array (int, byte, uint64, etc.)

 */

{

	/* Automatically calculate the length? */

	if (_sl.need_length != NL_NONE) {

	std::list<void *> *l = (std::list<void *> *) list;

	if (_sl.save) {

		std::list<void *>::iterator iter;

		for (iter = l->begin(); iter != l->end(); ++iter) {

 */

void SlAutolength(AutolengthProc *proc, void *arg)

{

	assert(_sl.save);

static void SlLoadChunk(const ChunkHandler *ch)

{

	byte m = SlReadByte();

	_sl.block_mode = m;

	_sl.obj_len = 0;

#include "minilzo.h"

{

	byte out[LZO_SIZE + LZO_SIZE / 64 + 16 + 3 + 8];

	uint32 tmp[2];

/* p contains the pointer to the buffer, len contains the pointer to the length.

 * len bytes will be written, p and l will be updated to reflect the next buffer. */

{

	byte out[LZO_SIZE + LZO_SIZE / 64 + 16 + 3 + 8];

	byte wrkmem[sizeof(byte*)*4096];

	uint outlen;

	((uint32*)out)[1] = TO_BE32(outlen);

	((uint32*)out)[0] = TO_BE32(lzo_adler32(0, out + sizeof(uint32), outlen + sizeof(uint32)));

	if (fwrite(out, outlen + sizeof(uint32)*2, 1, _sl.fh) != 1) SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);

/*********************************************

 ******** START OF NOCOMP CODE (uncompressed)*

 *********************************************/

{

	return fread(_sl.buf, 1, LZO_SIZE, _sl.fh);

}

{

	if (fwrite(_sl.buf, 1, size, _sl.fh) != size) SlError(STR_GAME_SAVELOAD_ERROR_FILE_NOT_WRITEABLE);

}

	_Savegame_pool.CleanPool();

}

{

	/* Allocate new block and new buffer-pointer */

	_Savegame_pool.AddBlockIfNeeded(_ts.count);

	_sl.buf = GetSavegame(_ts.count);

	return true;

}

{

	int r;

	return true;

}

{

	byte buf[1024]; // output buffer

	int r;

	uint n;

	z->next_in = p;

	do {

		z->next_out = buf;

		z->avail_out = sizeof(buf);

	} while (z->avail_in || !z->avail_out);

}

{

	WriteZlibLoop(&_z, _sl.buf, len, 0);

}

int SlIterateArray();

void SlAutolength(AutolengthProc *proc, void *arg);

void SlSetLength(size_t length);

size_t SlCalcObjMemberLength(const void *object, const SaveLoad *sld);

void SlWriteByte(byte b);

void SlGlobList(const SaveLoadGlobVarList *sldg);

void SlObject(void *object, const SaveLoad *sld);

bool SlObjectMember(void *object, const SaveLoad *sld);

	uint i;

	FioOpenFile(SOUND_SLOT, filename);

	uint count = FioReadDword() / 8;

	/* Simple check for the correct number of original sounds. */

struct FileEntry {

	uint8 file_slot;

	uint16 rate;

	uint8 bits_per_sample;

	uint8 channels;

struct SpriteCache {

	void *ptr;

	uint32 id;

	uint16 file_slot;

	int16 lru;

};

static void* ReadSprite(SpriteCache *sc, SpriteID id, bool real_sprite)

{

	uint8 file_slot = sc->file_slot;

	DEBUG(sprite, 9, "Load sprite %d", id);

bool LoadNextSprite(int load_index, byte file_slot, uint file_sprite_id)

{

	SpriteCache *sc;

	if (!ReadSpriteHeaderSkipData()) return false;

	return (MemBlock*)((byte*)block + (block->size & ~S_FREE_MASK));

}

{

	MemBlock* s;

	for (s = _spritecache_ptr; s->size != 0; s = NextBlock(s)) {

#include "../core/alloc_func.hpp"

#include "grf.hpp"

{

	/* Open the right file and go to the correct position */

	FioSeekToFile(file_slot, file_pos);

	/**

	 * Load a sprite from the disk and return a sprite struct which is the same for all loaders.

	 */

};

#endif /* SPRITELOADER_GRF_HPP */

	return true;

}

{

	const char *filename = FioGetFilename(file_slot);

	return true;

}

	/**

	 * Load a sprite from the disk and return a sprite struct which is the same for all loaders.

	 */

};

#endif /* SPRITELOADER_PNG_HPP */

	/**

	 * Load a sprite from the disk and return a sprite struct which is the same for all loaders.

	 */

	virtual ~SpriteLoader() { }

};

 */

struct StationViewWindow : public Window {

	uint32 cargo;                 ///< Bitmask of cargo types to expand

	StationViewWindow(const WindowDesc *desc, WindowNumber window_number) : Window(desc, window_number)

	{

				}

			}

		}

		/* disable some buttons */

		this->SetWidgetDisabledState(SVW_RENAME,   st->owner != _local_player);

		typedef _W64 unsigned int UINT_PTR, *PUINT_PTR;

	#endif /* WIN32 && !_WIN64 && !WIN64 */

	#define GCC_PACK

	/* This is needed to zlib uses the stdcall calling convention on visual studio */

 * @param c Unicode character.

 * @return Length of UTF-8 encoding for character.

 */

{

	if (c < 0x80)       return 1;

	if (c < 0x800)      return 2;

 * @param c char to query length of

 * @return requested size

 */

{

	if (GB(c, 3, 5) == 0x1E) return 4;

	if (GB(c, 4, 4) == 0x0E) return 3;

	static const Town *last_town;

	/* Constants for sorting towns */

	GUITownList towns;

const Town *TownDirectoryWindow::last_town = NULL;

/* Available town directory sorting functions */

	&TownNameSorter,

	&TownPopulationSorter,

};

		} else {

			/* ... and lastly if it won't, enable the scroll bar and fit the

			 * list in below the widget */

			int rows = (screen_bottom - 4 - top) / avg_height;

			height = rows * avg_height;

			scroll = true;

		dw->widget[0].right -= 12;

		/* Capacity is the average number of items visible */

	}

	dw->desc_flags = WDF_DEF_WIDGET;

	const char *ptr;

	WChar c;

	if (IsClipboardFormatAvailable(CF_UNICODETEXT)) {

		OpenClipboard(NULL);

	for (ptr = utf8_buf; (c = Utf8Consume(&ptr)) != '\0';) {

		if (!IsPrintable(c)) break;

		if (tb->length + length >= tb->maxlength - len) break;

		byte charwidth = GetCharacterWidth(FS_NORMAL, c);