BUFFER_SIZE = 4096,

	OLD_MAP_SIZE = 256 * 256

};

struct LoadgameState {

	FILE *file;

	uint chunk_size;

	bool decoding;

	byte decode_char;

	uint buffer_count;

	uint buffer_cur;

	byte buffer[BUFFER_SIZE];

	uint total_read;

	bool failed;

/* OldChunk-Type */

enum OldChunkType {

	OC_SIMPLE    = 0,

	OC_NULL      = 1,

	OC_CHUNK     = 2,

	OC_ASSERT    = 3,

	/* 8 bits allocated (256 max) */

	OC_VAR_I8    = 1 << 8,

	OC_VAR_U8    = 2 << 8,

	OC_VAR_I16   = 3 << 8,

	OC_VAR_U16   = 4 << 8,

	OC_VAR_I32   = 5 << 8,

	OC_VAR_U32   = 6 << 8,

	OC_VAR_I64   = 7 << 8,

	/* 8 bits allocated (256 max) */

	OC_FILE_I8   = 1 << 16,

	OC_FILE_U8   = 2 << 16,

	OC_FILE_I16  = 3 << 16,

	OC_FILE_U16  = 4 << 16,

	OC_FILE_I32  = 5 << 16,

	OC_FILE_U32  = 6 << 16,

	/* 8 bits allocated (256 max) */

	OC_INT8      = OC_VAR_I8   | OC_FILE_I8,

	OC_UINT8     = OC_VAR_U8   | OC_FILE_U8,

	OC_INT16     = OC_VAR_I16  | OC_FILE_I16,

	OC_UINT16    = OC_VAR_U16  | OC_FILE_U16,

	OC_INT32     = OC_VAR_I32  | OC_FILE_I32,

	OC_UINT32    = OC_VAR_U32  | OC_FILE_U32,

	OC_TILE      = OC_VAR_U32  | OC_FILE_U16,

	/**

	 * Dereference the pointer once before writing to it,

	 * so we do not have to use big static arrays.

	 */

	OC_DEREFERENCE_POINTER = 1 << 31,

	OC_END       = 0 ///< End of the whole chunk, all 32 bits set to zero

};

DECLARE_ENUM_AS_BIT_SET(OldChunkType);

typedef bool OldChunkProc(LoadgameState *ls, int num);

struct OldChunks {

	OldChunkType type;   ///< Type of field

	uint32 amount;       ///< Amount of fields

	void *ptr;           ///< Pointer where to save the data (may only be set if offset is 0)

	uint offset;         ///< Offset from basepointer (may only be set if ptr is NULL)

	OldChunkProc *proc;  ///< Pointer to function that is called with OC_CHUNK

};

/* If it fails, check lines above.. */

assert_compile(sizeof(TileIndex) == 4);

extern SavegameType _savegame_type;

extern uint32 _ttdp_version;

static uint32 _bump_assert_value;

static bool   _read_ttdpatch_flags;

static OldChunkType GetOldChunkType(OldChunkType type)     {return (OldChunkType)GB(type, 0, 8);}

static OldChunkType GetOldChunkVarType(OldChunkType type)  {return (OldChunkType)(GB(type, 8, 8) << 8);}

static OldChunkType GetOldChunkFileType(OldChunkType type) {return (OldChunkType)(GB(type, 16, 8) << 16);}

static byte ReadByte(LoadgameState *ls)

static inline uint16 ReadUint16(LoadgameState *ls)

{

	byte x = ReadByte(ls);

	return x | ReadByte(ls) << 8;

}

static inline uint32 ReadUint32(LoadgameState *ls)

{

	uint16 x = ReadUint16(ls);

	return x | ReadUint16(ls) << 16;

}

static bool LoadChunk(LoadgameState *ls, void *base, const OldChunks *chunks)

	_savegame_type   = SGT_TTD;

	_ttdp_version    = 0;

	_read_ttdpatch_flags = false;

/*

 * Begin -- Stuff to fix the savegames to be OpenTTD compatible

 */

static uint8  *_old_map3;

static void FixOldMapArray()

{

	/* _old_map3 is moved to _m::m3 and _m::m4 */

	for (TileIndex t = 0; t < OLD_MAP_SIZE; t++) {

		_m[t].m3 = _old_map3[t * 2];

		_m[t].m4 = _old_map3[t * 2 + 1];

	}

	for (TileIndex t = 0; t < OLD_MAP_SIZE; t++) {

		switch (GetTileType(t)) {

			case MP_STATION:

				_m[t].m4 = 0; // We do not understand this TTDP station mapping (yet)

				switch (_m[t].m5) {

					/* We have drive through stops at a totally different place */

					case 0x53: case 0x54: _m[t].m5 += 170 - 0x53; break; // Bus drive through

					case 0x57: case 0x58: _m[t].m5 += 168 - 0x57; break; // Truck drive through

					case 0x55: case 0x56: _m[t].m5 += 170 - 0x55; break; // Bus tram stop

					case 0x59: case 0x5A: _m[t].m5 += 168 - 0x59; break; // Truck tram stop

					default: break;

				}

				break;

			case MP_RAILWAY:

				/* We save presignals different from TTDPatch, convert them */

				if (GB(_m[t].m5, 6, 2) == 1) { // RAIL_TILE_SIGNALS

					/* This byte is always zero in TTD for this type of tile */

					if (_m[t].m4) { // Convert the presignals to our own format

						_m[t].m4 = (_m[t].m4 >> 1) & 7;

					}

				}

				/* TTDPatch stores PBS things in L6 and all elsewhere; so we'll just

				 * clear it for ourselves and let OTTD's rebuild PBS itself */

				_m[t].m4 &= 0xF; // Only keep the lower four bits; upper four is PBS

				break;

			case MP_WATER:

				/* if water class == 3, make river there */

				if (GB(_m[t].m3, 0, 2) == 3) {

					SetTileType(t, MP_WATER);

					SetTileOwner(t, OWNER_WATER);

					_m[t].m2 = 0;

					_m[t].m3 = 2; // WATER_CLASS_RIVER

					_m[t].m4 = Random();

					_m[t].m5 = 0;

				}

				break;

			default:

				break;

		}

	}

	/* Some old TTD(Patch) savegames could have buoys at tile 0

	 * (without assigned station struct) */

	MemSetT(&_m[0], 0);

	SetTileType(0, MP_WATER);

	SetTileOwner(0, OWNER_WATER);

}

extern uint32 GetOldTownName(uint32 townnameparts, byte old_town_name_type);

static void FixOldTowns()

{

	Town *town;

	/* Convert town-names if needed */

	FOR_ALL_TOWNS(town) {

		if (IsInsideMM(town->townnametype, 0x20C1, 0x20C3)) {

			town->townnametype = SPECSTR_TOWNNAME_ENGLISH + _settings_game.game_creation.town_name;

			town->townnameparts = GetOldTownName(town->townnameparts, _settings_game.game_creation.town_name);

		}

	}

}

static StringID *_old_vehicle_names = NULL;

static void FixOldVehicles()

{

	Vehicle *v;

	FOR_ALL_VEHICLES(v) {

		/* For some reason we need to correct for this */

		switch (v->spritenum) {

			case 0xfd: break;

			case 0xff: v->spritenum = 0xfe; break;

			default:   v->spritenum >>= 1; break;

		}

		/* Vehicle-subtype is different in TTD(Patch) */

		if (v->type == VEH_EFFECT) v->subtype = v->subtype >> 1;

		v->name = CopyFromOldName(_old_vehicle_names[v->index]);

		/* We haven't used this bit for stations for ages */

		if (v->type == VEH_ROAD &&

				v->u.road.state != RVSB_IN_DEPOT &&

				v->u.road.state != RVSB_WORMHOLE) {

			ClrBit(v->u.road.state, RVS_IS_STOPPING);

		}

		/* The subtype should be 0, but it sometimes isn't :( */

		if (v->type == VEH_ROAD) v->subtype = 0;

		/* Sometimes primary vehicles would have a nothing (invalid) order

		 * or vehicles that could not have an order would still have a

		 * (loading) order which causes assertions and the like later on.

		 */

		if (!IsCompanyBuildableVehicleType(v) ||

				(v->IsPrimaryVehicle() && v->current_order.IsType(OT_NOTHING))) {

			v->current_order.MakeDummy();

		}

		/* Shared orders are fixed in AfterLoadVehicles now */

	}

}

/*

 * End -- Stuff to fix the savegames to be OpenTTD compatible

 */

/* Help:

 *  - OCL_SVAR: load 'type' to offset 'offset' in a struct of type 'base', which must also

 *       be given via base in LoadChunk() as real pointer

 *  - OCL_VAR: load 'type' to a global var

 *  - OCL_END: every struct must end with this

 *  - OCL_NULL: read 'amount' of bytes and send them to /dev/null or something

 *  - OCL_CHUNK: load an other proc to load a part of the savegame, 'amount' times

 *  - OCL_ASSERT: to check if we are really at the place we expect to be.. because old savegames are too binary to be sure ;)

 */

#define OCL_SVAR(type, base, offset)         { type,          1, NULL,    (uint)cpp_offsetof(base, offset), NULL }

#define OCL_VAR(type, amount, pointer)       { type,     amount, pointer, 0,                      NULL }

#define OCL_END()                                   { OC_END,        0, NULL,    0,                      NULL }

#define OCL_NULL(amount)                            { OC_NULL,  amount, NULL,    0,                      NULL }

#define OCL_CHUNK(amount, proc)                     { OC_CHUNK, amount, NULL,    0,                      proc }

#define OCL_ASSERT(size)                            { OC_ASSERT,     1, NULL, size,                      NULL }

/* The savegames has some hard-coded pointers, because it always enters the same

 *  piece of memory.. we don't.. so we need to remap ;)

 * Old Towns are 94 bytes big

 * Old Orders are 2 bytes big */

#define REMAP_TOWN_IDX(x) ((x) - (0x0459154 - 0x0458EF0)) / 94

#define REMAP_ORDER_IDX(x) ((x) - (0x045AB08 - 0x0458EF0)) / 2

extern TileIndex *_animated_tile_list;

extern uint _animated_tile_count;

extern char *_old_name_array;

static byte   _old_vehicle_multiplier;

static uint32 _old_town_index;

static uint16 _old_string_id;

static uint16 _old_string_id_2;

static uint16 _old_extra_chunk_nums;

static void ReadTTDPatchFlags()

{

	if (_read_ttdpatch_flags) return;

	_read_ttdpatch_flags = true;

	/* TTDPatch misuses _old_map3 for flags.. read them! */

	_old_vehicle_multiplier = _old_map3[0];

	/* Somehow.... there was an error in some savegames, so 0 becomes 1

	and 1 becomes 2. The rest of the values are okay */

	if (_old_vehicle_multiplier < 2) _old_vehicle_multiplier++;

	_old_vehicle_names = MallocT<StringID>(_old_vehicle_multiplier * 850);

	/* TTDPatch increases the Vehicle-part in the middle of the game,

	so if the multipler is anything else but 1, the assert fails..

	bump the assert value so it doesn't!

	(1 multipler == 850 vehicles

	1 vehicle   == 128 bytes */

	_bump_assert_value = (_old_vehicle_multiplier - 1) * 850 * 128;

	for (uint i = 0; i < 17; i++) { // check tile 0, too

		if (_old_map3[i] != 0) _savegame_type = SGT_TTDP1;

	}

	/* Check if we have a modern TTDPatch savegame (has extra data all around) */

	if (memcmp(&_old_map3[0x1FFFA], "TTDp", 4) == 0) _savegame_type = SGT_TTDP2;

	_old_extra_chunk_nums = _old_map3[_savegame_type == SGT_TTDP2 ? 0x1FFFE : 0x2];

	/* Clean the misused places */

	for (uint i = 0;       i < 17;      i++) _old_map3[i] = 0;

	for (uint i = 0x1FE00; i < 0x20000; i++) _old_map3[i] = 0;

	if (_savegame_type == SGT_TTDP2) DEBUG(oldloader, 2, "Found TTDPatch game");

	DEBUG(oldloader, 3, "Vehicle-multiplier is set to %d (%d vehicles)", _old_vehicle_multiplier, _old_vehicle_multiplier * 850);

}

static const OldChunks town_chunk[] = {

	OCL_SVAR(   OC_TILE, Town, xy ),

	OCL_NULL( 2 ),         ///< population,        no longer in use

	OCL_SVAR( OC_UINT16, Town, townnametype ),

	OCL_SVAR( OC_UINT32, Town, townnameparts ),

	OCL_SVAR(  OC_UINT8, Town, grow_counter ),

	OCL_NULL( 1 ),         ///< sort_index,        no longer in use

	OCL_NULL( 4 ),         ///< sign-coordinates,  no longer in use

	OCL_NULL( 2 ),         ///< namewidth,         no longer in use

	OCL_SVAR( OC_UINT16, Town, flags12 ),

	OCL_NULL( 10 ),        ///< radius,            no longer in use

	OCL_SVAR( OC_UINT16, Town, ratings[0] ),

	OCL_SVAR( OC_UINT16, Town, ratings[1] ),

	OCL_SVAR( OC_UINT16, Town, ratings[2] ),

	OCL_SVAR( OC_UINT16, Town, ratings[3] ),

	OCL_SVAR( OC_UINT16, Town, ratings[4] ),

	OCL_SVAR( OC_UINT16, Town, ratings[5] ),

	OCL_SVAR( OC_UINT16, Town, ratings[6] ),

	OCL_SVAR( OC_UINT16, Town, ratings[7] ),

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U16, Town, have_ratings ),

	OCL_SVAR( OC_FILE_U32 | OC_VAR_U16, Town, statues ),

	OCL_NULL( 2 ),         ///< num_houses,        no longer in use

	OCL_SVAR(  OC_UINT8, Town, time_until_rebuild ),

	OCL_SVAR(  OC_UINT8, Town, growth_rate ),

	OCL_SVAR( OC_UINT16, Town, new_max_pass ),

	OCL_SVAR( OC_UINT16, Town, new_max_mail ),

	OCL_SVAR( OC_UINT16, Town, new_act_pass ),

	OCL_SVAR( OC_UINT16, Town, new_act_mail ),

	OCL_SVAR( OC_UINT16, Town, max_pass ),

	OCL_SVAR( OC_UINT16, Town, max_mail ),

	OCL_SVAR( OC_UINT16, Town, act_pass ),

	OCL_SVAR( OC_UINT16, Town, act_mail ),

	OCL_SVAR(  OC_UINT8, Town, pct_pass_transported ),

	OCL_SVAR(  OC_UINT8, Town, pct_mail_transported ),

	OCL_SVAR( OC_UINT16, Town, new_act_food ),

	OCL_SVAR( OC_UINT16, Town, new_act_water ),

	OCL_SVAR( OC_UINT16, Town, act_food ),

	OCL_SVAR( OC_UINT16, Town, act_water ),

	OCL_SVAR(  OC_UINT8, Town, road_build_months ),

	OCL_SVAR(  OC_UINT8, Town, fund_buildings_months ),

	OCL_NULL( 8 ),         ///< some junk at the end of the record

	OCL_END()

};

static bool LoadOldTown(LoadgameState *ls, int num)

{

	Town *t = new (num) Town();

	if (!LoadChunk(ls, t, town_chunk)) return false;

	if (t->xy == 0) t->xy = INVALID_TILE;

	return true;

}

static uint16 _old_order;

static const OldChunks order_chunk[] = {

	OCL_VAR ( OC_UINT16,   1, &_old_order ),

	OCL_END()

};

static bool LoadOldOrder(LoadgameState *ls, int num)

{

	if (!LoadChunk(ls, NULL, order_chunk)) return false;

	new (num) Order(UnpackOldOrder(_old_order));

	/* Relink the orders to eachother (in TTD(Patch) the orders for one

	vehicle are behind eachother, with an invalid order (OT_NOTHING) as indication that

	it is the last order */

	if (num > 0 && GetOrder(num)->IsValid())

		GetOrder(num - 1)->next = GetOrder(num);

	return true;

}

static bool LoadOldAnimTileList(LoadgameState *ls, int num)

{

	/* This is sligthly hackish - we must load a chunk into an array whose

	 * address isn't static, but instead pointed to by _animated_tile_list.

	 * To achieve that, create an OldChunks list on the stack on the fly.

	 * The list cannot be static because the value of _animated_tile_list

	 * can change between calls. */

	const OldChunks anim_chunk[] = {

		OCL_VAR (   OC_TILE, 256, _animated_tile_list ),

		OCL_END ()

	};

	if (!LoadChunk(ls, NULL, anim_chunk)) return false;

	/* Update the animated tile counter by counting till the first zero in the array */

	for (_animated_tile_count = 0; _animated_tile_count < 256; _animated_tile_count++) {

		if (_animated_tile_list[_animated_tile_count] == 0) break;

	}

	return true;

}

static const OldChunks depot_chunk[] = {

	OCL_SVAR(   OC_TILE, Depot, xy ),

	OCL_VAR ( OC_UINT32,   1, &_old_town_index ),

	OCL_END()

};

static bool LoadOldDepot(LoadgameState *ls, int num)

{

	Depot *d = new (num) Depot();

	if (!LoadChunk(ls, d, depot_chunk)) return false;

	if (d->xy != 0) {

		GetDepot(num)->town_index = REMAP_TOWN_IDX(_old_town_index);

	} else {

		d->xy = INVALID_TILE;

	}

	return true;

}

static int32 _old_price;

static uint16 _old_price_frac;

static const OldChunks price_chunk[] = {

	OCL_VAR (  OC_INT32,   1, &_old_price ),

	OCL_VAR ( OC_UINT16,   1, &_old_price_frac ),

	OCL_END()

};

static bool LoadOldPrice(LoadgameState *ls, int num)

{

	if (!LoadChunk(ls, NULL, price_chunk)) return false;

	/* We use a struct to store the prices, but they are ints in a row..

	so just access the struct as an array of int32's */

	((Money*)&_price)[num] = _old_price;

	_price_frac[num] = _old_price_frac;

	return true;

}

static const OldChunks cargo_payment_rate_chunk[] = {

	OCL_VAR (  OC_INT32,   1, &_old_price ),

	OCL_VAR ( OC_UINT16,   1, &_old_price_frac ),

	OCL_NULL( 2 ),         ///< Junk

	OCL_END()

};

static bool LoadOldCargoPaymentRate(LoadgameState *ls, int num)

{

	if (!LoadChunk(ls, NULL, cargo_payment_rate_chunk)) return false;

	_cargo_payment_rates[num] = -_old_price;

	_cargo_payment_rates_frac[num] = _old_price_frac;

	return true;

}

static uint   _current_station_id;

static uint16 _waiting_acceptance;

static uint8  _cargo_source;

static uint8  _cargo_days;

static const OldChunks goods_chunk[] = {

	OCL_VAR ( OC_UINT16, 1,          &_waiting_acceptance ),

	OCL_SVAR(  OC_UINT8, GoodsEntry, days_since_pickup ),

	OCL_SVAR(  OC_UINT8, GoodsEntry, rating ),

	OCL_VAR (  OC_UINT8, 1,          &_cargo_source ),

	OCL_VAR (  OC_UINT8, 1,          &_cargo_days ),

	OCL_SVAR(  OC_UINT8, GoodsEntry, last_speed ),

	OCL_SVAR(  OC_UINT8, GoodsEntry, last_age ),

	OCL_END()

};

static bool LoadOldGood(LoadgameState *ls, int num)

{

	Station *st = GetStation(_current_station_id);

	GoodsEntry *ge = &st->goods[num];

	bool ret = LoadChunk(ls, ge, goods_chunk);

	if (!ret) return false;

	SB(ge->acceptance_pickup, GoodsEntry::ACCEPTANCE, 1, HasBit(_waiting_acceptance, 15));

	SB(ge->acceptance_pickup, GoodsEntry::PICKUP, 1, _cargo_source != 0xFF);

	if (GB(_waiting_acceptance, 0, 12) != 0) {

		CargoPacket *cp = new CargoPacket();

		cp->source          = (_cargo_source == 0xFF) ? INVALID_STATION : _cargo_source;

		cp->count           = GB(_waiting_acceptance, 0, 12);

		cp->days_in_transit = _cargo_days;

		ge->cargo.Append(cp);

	}

	return ret;

}

static const OldChunks station_chunk[] = {

	OCL_SVAR(   OC_TILE, Station, xy ),

	OCL_VAR ( OC_UINT32,   1, &_old_town_index ),

	OCL_NULL( 4 ), ///< bus/lorry tile

	OCL_SVAR(   OC_TILE, Station, train_tile ),

	OCL_SVAR(   OC_TILE, Station, airport_tile ),

	OCL_SVAR(   OC_TILE, Station, dock_tile ),

	OCL_SVAR(  OC_UINT8, Station, trainst_w ),

	OCL_NULL( 1 ),         ///< sort-index, no longer in use

	OCL_NULL( 2 ),         ///< sign-width, no longer in use

	OCL_VAR ( OC_UINT16,   1, &_old_string_id ),

	OCL_NULL( 4 ),         ///< sign left/top, no longer in use

	OCL_SVAR( OC_UINT16, Station, had_vehicle_of_type ),

	OCL_CHUNK( 12, LoadOldGood ),

	OCL_SVAR(  OC_UINT8, Station, time_since_load ),

	OCL_SVAR(  OC_UINT8, Station, time_since_unload ),

	OCL_SVAR(  OC_UINT8, Station, delete_ctr ),

	OCL_SVAR(  OC_UINT8, Station, owner ),

	OCL_SVAR(  OC_UINT8, Station, facilities ),

	OCL_SVAR(  OC_UINT8, Station, airport_type ),

	/* Bus/truck status, no longer in use

	 * Blocked months

	 * Unknown

	 */

	OCL_NULL( 4 ),

	OCL_SVAR( OC_FILE_U16 | OC_VAR_U32, Station, airport_flags ),

	OCL_NULL( 2 ),         ///< last_vehicle. now last_vehicle_type

	OCL_NULL( 4 ),         ///< Junk at end of chunk

	OCL_END()

};

static bool LoadOldStation(LoadgameState *ls, int num)

{

	Station *st = new (num) Station();

	_current_station_id = num;

	if (!LoadChunk(ls, st, station_chunk))

		return false;

	if (st->xy != 0) {

		st->town    = GetTown(REMAP_TOWN_IDX(_old_town_index));

		st->string_id = RemapOldStringID(_old_string_id);

	} else {

		st->xy = INVALID_TILE;

	}

	return true;

}

static const OldChunks industry_chunk[] = {

	OCL_SVAR(   OC_TILE, Industry, xy ),

	OCL_VAR ( OC_UINT32,   1, &_old_town_index ),

	OCL_SVAR(  OC_UINT8, Industry, width ),

	OCL_SVAR(  OC_UINT8, Industry, height ),

	OCL_NULL( 2 ),  ///< used to be industry's produced_cargo

	OCL_SVAR( OC_UINT16, Industry, produced_cargo_waiting[0] ),

	OCL_SVAR( OC_UINT16, Industry, produced_cargo_waiting[1] ),

	OCL_SVAR(  OC_UINT8, Industry, production_rate[0] ),

	OCL_SVAR(  OC_UINT8, Industry, production_rate[1] ),

	OCL_NULL( 3 ),  ///< used to be industry's accepts_cargo

	OCL_SVAR(  OC_UINT8, Industry, prod_level ),

	OCL_SVAR( OC_UINT16, Industry, this_month_production[0] ),

	OCL_SVAR( OC_UINT16, Industry, this_month_production[1] ),

	OCL_SVAR( OC_UINT16, Industry, this_month_transported[0] ),

	OCL_SVAR( OC_UINT16, Industry, this_month_transported[1] ),

	OCL_SVAR(  OC_UINT8, Industry, last_month_pct_transported[0] ),

	OCL_SVAR(  OC_UINT8, Industry, last_month_pct_transported[1] ),

	OCL_SVAR( OC_UINT16, Industry, last_month_production[0] ),

	OCL_SVAR( OC_UINT16, Industry, last_month_production[1] ),

	OCL_SVAR( OC_UINT16, Industry, last_month_transported[0] ),

	OCL_SVAR( OC_UINT16, Industry, last_month_transported[1] ),

	OCL_SVAR(  OC_UINT8, Industry, type ),

	OCL_SVAR(  OC_UINT8, Industry, owner ),

	OCL_SVAR(  OC_UINT8, Industry, random_color ),

	OCL_SVAR( OC_FILE_U8 | OC_VAR_I32, Industry, last_prod_year ),

	OCL_SVAR( OC_UINT16, Industry, counter ),

	OCL_SVAR(  OC_UINT8, Industry, was_cargo_delivered ),

	OCL_NULL( 9 ), ///< Random junk at the end of this chunk

	OCL_END()

};

static bool LoadOldIndustry(LoadgameState *ls, int num)

{

	Industry *i = new (num) Industry();

	if (!LoadChunk(ls, i, industry_chunk)) return false;

	if (i->xy != 0) {

		i->town = GetTown(REMAP_TOWN_IDX(_old_town_index));

		IncIndustryTypeCount(i->type);

	} else {

		i->xy = INVALID_TILE;

	}

	return true;

}

static CompanyID _current_company_id;

static int32 _old_yearly;

static const OldChunks _company_yearly_chunk[] = {

	OCL_VAR(  OC_INT32,   1, &_old_yearly ),

	OCL_END()

};

static bool OldCompanyYearly(LoadgameState *ls, int num)

{

	int i;

	Company *c = GetCompany(_current_company_id);

	for (i = 0; i < 13; i++) {

		if (!LoadChunk(ls, NULL, _company_yearly_chunk)) return false;

		c->yearly_expenses[num][i] = _old_yearly;

	}

	return true;

}

static const OldChunks _company_economy_chunk[] = {

	OCL_SVAR( OC_FILE_I32 | OC_VAR_I64, CompanyEconomyEntry, income ),

	OCL_SVAR( OC_FILE_I32 | OC_VAR_I64, CompanyEconomyEntry, expenses ),

	OCL_SVAR( OC_INT32,                 CompanyEconomyEntry, delivered_cargo ),

	OCL_SVAR( OC_INT32,                 CompanyEconomyEntry, performance_history ),

	OCL_SVAR( OC_FILE_I32 | OC_VAR_I64, CompanyEconomyEntry, company_value ),

	OCL_END()

};

static bool OldCompanyEconomy(LoadgameState *ls, int num)

{

	int i;

	Company *c = GetCompany(_current_company_id);

	if (!LoadChunk(ls, &c->cur_economy, _company_economy_chunk)) return false;

	/* Don't ask, but the number in TTD(Patch) are inversed to OpenTTD */

	c->cur_economy.income   = -c->cur_economy.income;

	c->cur_economy.expenses = -c->cur_economy.expenses;

	for (i = 0; i < 24; i++) {

		if (!LoadChunk(ls, &c->old_economy[i], _company_economy_chunk)) return false;

		c->old_economy[i].income   = -c->old_economy[i].income;

		c->old_economy[i].expenses = -c->old_economy[i].expenses;

	}

	return true;

}

static const OldChunks _company_chunk[] = {

	OCL_VAR ( OC_UINT16,   1, &_old_string_id ),

	OCL_SVAR( OC_UINT32, Company, name_2 ),

	OCL_SVAR( OC_UINT32, Company, face ),

	OCL_VAR ( OC_UINT16,   1, &_old_string_id_2 ),

	OCL_SVAR( OC_UINT32, Company, president_name_2 ),

	OCL_SVAR( OC_FILE_I32 | OC_VAR_I64, Company, money ),

	OCL_SVAR( OC_FILE_I32 | OC_VAR_I64, Company, current_loan ),