for (ss = _subsidies; ss != endof(_subsidies); ss++) {

		if (s != ss &&

				ss->from == s->from &&

				ss->to == s->to &&

				ss->cargo_type == s->cargo_type) {

			s->cargo_type = CT_INVALID;

			return true;

		}

	}

	return false;

}

static void SubsidyMonthlyHandler(void)

{

	Subsidy *s;

	Pair pair;

	Station *st;

	uint n;

	FoundRoute fr;

	bool modified = false;

	for(s=_subsidies; s != endof(_subsidies); s++) {

		if (s->age == 12-1) {

			pair = SetupSubsidyDecodeParam(s, 1);

			AddNewsItem(STR_202E_OFFER_OF_SUBSIDY_EXPIRED, NEWS_FLAGS(NM_NORMAL, NF_TILE, NT_SUBSIDIES, 0), pair.a, pair.b);

			s->cargo_type = CT_INVALID;

			modified = true;

		} else if (s->age == 2*12-1) {

			st = GetStation(s->to);

			if (st->owner == _local_player) {

				pair = SetupSubsidyDecodeParam(s, 1);

				AddNewsItem(STR_202F_SUBSIDY_WITHDRAWN_SERVICE, NEWS_FLAGS(NM_NORMAL, NF_TILE, NT_SUBSIDIES, 0), pair.a, pair.b);

			}

			s->cargo_type = CT_INVALID;

			modified = true;

		} else {

			s->age++;

		}

	}

	// 25% chance to go on

	if (CHANCE16(1,4)) {

		// Find a free slot

		s = _subsidies;

		while (s->cargo_type != CT_INVALID) {

	if (mode == GW_EMPTY) {

		// empty world in scenario editor

		ConvertGroundTilesIntoWaterTiles();

	} else {

		GenerateLandscape();

		GenerateClearTile();

		// only generate towns, tree and industries in newgame mode.

		if (mode == GW_NEWGAME) {

			GenerateTowns();

			GenerateTrees();

			GenerateIndustries();

			GenerateUnmovables();

		}

	}

	// These are probably pointless when inside the scenario editor.

	StartupPlayers();

	StartupEngines();

	StartupDisasters();

	_generating_world = false;

	// No need to run the tile loop in the scenario editor.

	if (mode != GW_EMPTY) {

	}

	ResetObjectToPlace();

}

void DeleteName(StringID id)

{

	if ((id & 0xF800) == 0x7800) {

		memset(_name_array[id & 0x1FF], 0, sizeof(_name_array[id & 0x1FF]));

	}

}

char *GetName(int id, char *buff)

{

	return strecpy(buff, _name_array[id & ~0x600], NULL);

}

static void InitializeCheats(void)

{

	memset(&_cheats, 0, sizeof(Cheats));

}

					HandleButtonClick(w, 12);

		}

		break;

	case WE_TIMEOUT:

		if (HASBIT(w->click_state, 11)) { /* Delete button clicked */

			if (!FiosDelete(WP(w,querystr_d).text.buf)) {

				ShowErrorMessage(INVALID_STRING_ID, STR_4008_UNABLE_TO_DELETE_FILE, 0, 0);

			}

			SetWindowDirty(w);

			BuildFileList();

			if (_saveload_mode == SLD_SAVE_GAME) {

				GenerateFileName(); /* Reset file name to current date */

				UpdateTextBufferSize(&WP(w, querystr_d).text);

			}

		} else if (HASBIT(w->click_state, 12)) { /* Save button clicked */

			_switch_mode = SM_SAVE;

			FiosMakeSavegameName(_file_to_saveload.name, WP(w,querystr_d).text.buf);

			/* In the editor set up the vehicle engines correctly (date might have changed) */

			if (_game_mode == GM_EDITOR) StartupEngines();

		}

		break;

	case WE_DESTROY:

		// pause is only used in single-player, non-editor mode, non menu mode

			DoCommandP(0, 0, 0, NULL, CMD_PAUSE);

		FiosFreeSavegameList();

		CLRBIT(_no_scroll, SCROLL_SAVE);

		break;

	case WE_RESIZE: {

		/* Widget 2 and 3 have to go with halve speed, make it so obiwan */

		uint diff = e->sizing.diff.x / 2;

		w->widget[2].right += diff;

		w->widget[3].left  += diff;

		w->widget[3].right += e->sizing.diff.x;

		/* Same for widget 11 and 12 in save-dialog */

		if (_saveload_mode == SLD_SAVE_GAME || _saveload_mode == SLD_SAVE_SCENARIO) {

			w->widget[11].right += diff;

			w->widget[12].left  += diff;

			w->widget[12].right += e->sizing.diff.x;

		}

		w->vscroll.cap += e->sizing.diff.y / 10;

		} break;

	}

}

static const WindowDesc _load_dialog_desc = {

	WDP_CENTER, WDP_CENTER, 257, 294,

		str = SPECSTR_ANDCO_NAME;

		strp = p->president_name_2;

		goto set_name;

	} else {

		str = SPECSTR_ANDCO_NAME;

		strp = Random();

		goto verify_name;

	}

}

#define COLOR_SWAP(i,j) do { byte t=colors[i];colors[i]=colors[j];colors[j]=t; } while(0)

static const byte _color_sort[16] = {2, 2, 3, 2, 3, 2, 3, 2, 3, 2, 2, 2, 3, 1, 1, 1};

static const byte _color_similar_1[16] = {8, 6, 255, 12,  255, 0, 1, 1, 0, 13,  11,  10, 3,   9,  15, 14};

static const byte _color_similar_2[16] = {5, 7, 255, 255, 255, 8, 7, 6, 5, 12, 255, 255, 9, 255, 255, 255};

static byte GeneratePlayerColor(void)

{

	byte colors[16], pcolor, t2;

	int i,j,n;

	uint32 r;

	Player *p;

	// Initialize array

	// And randomize it

	n = 100;

	do {

		r = Random();

		COLOR_SWAP(GB(r, 0, 4), GB(r, 4, 4));

	} while (--n);

	// Bubble sort it according to the values in table 1

	i = 16;

	do {

		for(j=0; j!=15; j++) {

			if (_color_sort[colors[j]] < _color_sort[colors[j+1]]) {

				COLOR_SWAP(j,j+1);

			}

		}

	} while (--i);

	// Move the colors that look similar to each player's color to the side

	FOR_ALL_PLAYERS(p) if (p->is_active) {

		pcolor = p->player_color;

		for(i=0; i!=16; i++) if (colors[i] == pcolor) {

			colors[i] = 0xFF;

	SLE_ARR(PlayerAI,wagon_list,				SLE_UINT16, 9),

	SLE_ARR(PlayerAI,order_list_blocks,	SLE_UINT8, 20),

	SLE_ARR(PlayerAI,banned_tiles,			SLE_UINT16, 16),

	SLE_CONDARR(NullStruct,null,SLE_FILE_U64 | SLE_VAR_NULL, 8, 2, 255),

	SLE_END()

};

static const SaveLoad _player_ai_build_rec_desc[] = {

	SLE_CONDVAR(AiBuildRec,spec_tile, SLE_FILE_U16 | SLE_VAR_U32, 0, 5),

	SLE_CONDVAR(AiBuildRec,spec_tile, SLE_UINT32, 6, 255),

	SLE_CONDVAR(AiBuildRec,use_tile,  SLE_FILE_U16 | SLE_VAR_U32, 0, 5),

	SLE_CONDVAR(AiBuildRec,use_tile,  SLE_UINT32, 6, 255),

	SLE_VAR(AiBuildRec,rand_rng,			SLE_UINT8),

	SLE_VAR(AiBuildRec,cur_building_rule,SLE_UINT8),

	SLE_VAR(AiBuildRec,unk6,					SLE_UINT8),

	SLE_VAR(AiBuildRec,unk7,					SLE_UINT8),

	SLE_VAR(AiBuildRec,buildcmd_a,		SLE_UINT8),

	SLE_VAR(AiBuildRec,buildcmd_b,		SLE_UINT8),

	SLE_VAR(AiBuildRec,direction,			SLE_UINT8),

	SLE_VAR(AiBuildRec,cargo,					SLE_UINT8),

	SLE_END()

};

	int i;

	SlObject(p, _player_desc);

	// Write AI?

	if (!IS_HUMAN_PLAYER(p->index)) {

		SlObject(&p->ai, _player_ai_desc);

		for(i=0; i!=p->ai.num_build_rec; i++)

			SlObject(&p->ai.src + i, _player_ai_build_rec_desc);

	}

	// Write economy

	SlObject(&p->cur_economy, _player_economy_desc);

	// Write old economy entries.

	{

		PlayerEconomyEntry *pe;

		for(i=p->num_valid_stat_ent,pe=p->old_economy; i!=0; i--,pe++)

			SlObject(pe, _player_economy_desc);

	}

}

static void Save_PLYR(void)

{

			while (true) {

				if (((ch->flags >> CH_PRI_SHL) & (CH_NUM_PRI_LEVELS - 1)) == p)

					SlSaveChunk(ch);

				if (ch->flags & CH_LAST)

					break;

				ch++;

			}

		}

	}

	// Terminator

	SlWriteUint32(0);

}

/** Find the ChunkHandler that will be used for processing the found

 * chunk in the savegame or in memory

 * @param id the chunk in question

 * @return returns the appropiate chunkhandler

 */

static const ChunkHandler *SlFindChunkHandler(uint32 id)

{

	const ChunkHandler *ch;

	const ChunkHandler *const *chsc;

	for (chsc = _sl.chs; (ch=*chsc++) != NULL;) {

			ch++;

		}

	}

	return NULL;

}

/** Load all chunks */

static void SlLoadChunks(void)

{

	uint32 id;

	const ChunkHandler *ch;

	for (id = SlReadUint32(); id != 0; id = SlReadUint32()) {

		DEBUG(misc, 1) ("Loading chunk %c%c%c%c", id >> 24, id>>16, id>>8, id);

		ch = SlFindChunkHandler(id);

		if (ch == NULL) SlError("found unknown tag in savegame (sync error)");

		SlLoadChunk(ch);

	}

}

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

//********** START OF LZO CODE **************

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

	switch(type) {

	case SDT_INT8 >> 4:

	case SDT_UINT8 >> 4:

		for(i=0; i!=nitems; i++) ((byte*)array)[i] = items[i];

		break;

	case SDT_INT16 >> 4:

	case SDT_UINT16 >> 4:

		for(i=0; i!=nitems; i++) ((uint16*)array)[i] = items[i];

		break;

	case SDT_INT32 >> 4:

	case SDT_UINT32 >> 4:

		for(i=0; i!=nitems; i++) ((uint32*)array)[i] = items[i];

		break;

	default:

		NOT_REACHED();

	}

	return true;

}

static void make_intlist(char *buf, void *array, int nelems, int type)

{

	int i, v = 0;

	byte *p = (byte*)array;

	for(i=0; i!=nelems; i++) {

		switch(type) {

		case SDT_INT8 >> 4: v = *(int8*)p; p += 1; break;

		case SDT_UINT8 >> 4:v = *(byte*)p; p += 1; break;

		case SDT_INT16 >> 4:v = *(int16*)p; p += 2; break;

		case SDT_UINT16 >> 4:v = *(uint16*)p; p += 2; break;

		case SDT_INT32 >> 4:v = *(int32*)p; p += 4; break;

		case SDT_UINT32 >> 4:v = *(uint32*)p; p += 4; break;

		default: NOT_REACHED();

		}

		buf += sprintf(buf, i ? ",%d" : "%d", v);

	}

}

static void make_oneofmany(char *buf, const char *many, int i)

{

	int orig_i = i;

	char c;

	while (--i >= 0) {

		do {

			many++;

			if (many[-1] == 0) {

				sprintf(buf, "%d", orig_i);

		// proceed until whitespace or NUL

		r = s;

		for(;;) {

			if (*s == 0)

				break;

			if (*s == ' ' || *s == '\t') {

				*s++ = 0;

				break;

			}

			s++;

		}

	}

	*buf = s;

	return r;

}

// Forward declaration

static int TranslateArgumentIdx(int arg);

static void EmitWordList(char **words, int nw)

{

	int i,j;

	PutByte(nw);

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

		for(j=0; words[i][j]; j++)

			PutByte(words[i][j]);

	}

}

static void EmitPlural(char *buf, int value)

{

	int argidx = _cur_argidx;

	char *words[5];

	int nw = 0;

	// Parse out the number, if one exists. Otherwise default to prev arg.

	if (!ParseRelNum(&buf, &argidx))

		argidx--;

	// Parse each string

	for (nw = 0; nw < 5; nw++) {

		words[nw] = ParseWord(&buf);

		if (!words[nw])

			break;

	}

	if (nw == 0)

				for(; nw < _plural_form_counts[_lang_pluralform]; nw++) {

					words[nw] = words[nw - 1];

				}

			}

		}

	}

	PutByte(0x8D);

	PutByte(TranslateArgumentIdx(argidx));

	EmitWordList(words, nw);

}

static void EmitGender(char *buf, int value)

{

	int argidx = _cur_argidx;

	char *words[8];

	int nw;

	if (buf[0] == '=') {

		buf++;

		// This is a {G=DER} command

		for(nw=0; ;nw++) {

			if (!strcmp(buf, _genders[nw]))

				break;

		}

		// now nw contains the gender index

		PutByte(0x87);

		PutByte(nw);

	} else {

		// This is a {G 0 foo bar two} command.

		// If no relative number exists, default to +0

		if (!ParseRelNum(&buf, &argidx)) {}

		for(nw=0; nw<8; nw++) {

			words[nw] = ParseWord(&buf);

			if (!words[nw])

				break;

		}

		if (nw != _numgenders) Fatal("Bad # of arguments for gender command");

		PutByte(0x85);

		PutByte(13);

		PutByte(TranslateArgumentIdx(argidx));

		EmitWordList(words, nw);

	}

}

	// Used in:

	//   Croatian, Czech, Russian, Slovak, Ukrainian

	case 6:

		return n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;

	// Three forms, special case for one and some numbers ending in 2, 3, or 4

	// Used in:

	//   Polish

	case 7:

		return n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;

	// Four forms, special case for one and all numbers ending in 02, 03, or 04

	// Used in:

	//   Slovenian

	case 8:

		return n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3;

	}

}

static const char *ParseStringChoice(const char *b, uint form, char *dst, int *dstlen)

{

	//<NUM> {Length of each string} {each string}

	uint n = (byte)*b++;

	uint pos,i, mylen=0,mypos=0;

	for(i=pos=0; i!=n; i++) {

		uint len = (byte)*b++;

		if (i == form) {

			mypos = pos;

			mylen = len;

		}

		pos += len;

	}

	*dstlen = mylen;

	memcpy(dst, b + mypos, mylen);

	return b + pos;

}

static char *FormatString(char *buff, const char *str, const int32 *argv, uint casei)

{

	byte b;

	const int32 *argv_orig = argv;

	uint modifier = 0;

	while ((b = *str++) != '\0') {

		switch (b) {

		case 0x1: // {SETX}

			*buff++ = b;

	smallest = 0;

	for (i = 0; i != lengthof(t->radius); i++) {

		if (dist < t->radius[i])

			smallest = i;

	}

	return smallest;

}

static bool CheckFree2x2Area(Town *t1, TileIndex tile)

{

	int i;

	static const TileIndexDiffC _tile_add[] = {

		{0    , 0    },

		{0 - 0, 1 - 0},

		{1 - 0, 0 - 1},

		{1 - 1, 1 - 0}

	};

	for(i=0; i!=4; i++) {

		tile += ToTileIndexDiff(_tile_add[i]);

		if (CmdFailed(DoCommandByTile(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER | DC_FORCETEST, CMD_LANDSCAPE_CLEAR)))

			return false;

	}

	return true;

}

static void DoBuildTownHouse(Town *t, TileIndex tile)

{

	int i;

	uint bitmask;

	int house;

	uint slope;

	uint z;

	uint oneof;

	// Above snow?

	slope = GetTileSlope(tile, &z);

	// Get the town zone type

	{

		uint rad = GetTownRadiusGroup(t, tile);

	if (_patches.new_pathfinding_all) { /* Use a new pathfinding for everything */

		NPFFindStationOrTileData fstd;

		NPFFoundTargetData ftd;

		byte trackdir, trackdir_rev;

		Vehicle* last = GetLastVehicleInChain(v);

		NPFFillWithOrderData(&fstd, v);

		trackdir = GetVehicleTrackdir(v);

		trackdir_rev = ReverseTrackdir(GetVehicleTrackdir(last));

		assert(trackdir != 0xff);

		assert(trackdir_rev != 0xff);

		ftd = NPFRouteToStationOrTileTwoWay(v->tile, trackdir, last->tile, trackdir_rev, &fstd, TRANSPORT_RAIL, v->owner, v->u.rail.railtype);

		if (ftd.best_bird_dist != 0) {

			/* We didn't find anything, just keep on going straight ahead */

			reverse_best = false;

		} else {

			if (NPFGetFlag(&ftd.node, NPF_FLAG_REVERSE))

				reverse_best = true;

			else

				reverse_best = false;

		}

	} else {

			fd.best_bird_dist = (uint)-1;

			fd.best_track_dist = (uint)-1;

			NewTrainPathfind(v->tile, v->dest_tile, reverse ^ i, (NTPEnumProc*)NtpCallbFindStation, &fd);

			if (best_track != -1) {

				if (best_bird_dist != 0) {

					if (fd.best_bird_dist != 0) {

						/* neither reached the destination, pick the one with the smallest bird dist */

						if (fd.best_bird_dist > best_bird_dist) goto bad;

						if (fd.best_bird_dist < best_bird_dist) goto good;

					} else {

						/* we found the destination for the first time */

						goto good;

					}

				} else {

					if (fd.best_bird_dist != 0) {

						/* didn't find destination, but we've found the destination previously */

						goto bad;

					} else {

						/* both old & new reached the destination, compare track length */

						if (fd.best_track_dist > best_track_dist) goto bad;

						if (fd.best_track_dist < best_track_dist) goto good;

					}

	if (image != 0) {

		int back_height, front_height, i=z;

		const byte *p;

		static const byte _tileh_bits[4][8] = {

			{2,1,8,4,  16,11,0,9},

			{1,8,4,2,  11,16,9,0},

			{4,8,1,2,  16,11,0,9},

			{2,4,8,1,  11,16,9,0},

		};

		if (_display_opt & DO_TRANS_BUILDINGS) MAKE_TRANSPARENT(image);

		p = _tileh_bits[(image & 1) * 2 + (ti->map5&0x01)];

		front_height = ti->z + ((ti->tileh & p[0])?8:0);

		back_height = ti->z + ((ti->tileh & p[1])?8:0);

		if (IsSteepTileh(ti->tileh)) {

			if (!(ti->tileh & p[2])) front_height += 8;

			if (!(ti->tileh & p[3])) back_height += 8;

		}

		for(; z>=front_height || z>=back_height; z=z-8) {

		}

	}

}

uint GetBridgeFoundation(uint tileh, byte direction)

{

	int i;

	// normal level sloped building (7, 11, 13, 14)

	if (BRIDGE_FULL_LEVELED_FOUNDATION & (1 << tileh))

		return tileh;

	// inclined sloped building

	if (	((i=0, tileh == 1) || (i+=2, tileh == 2) || (i+=2, tileh == 4) || (i+=2, tileh == 8)) &&

				( direction == 0 || (i++, direction == 1)) )

		return i + 15;

	return 0;

}

/**

  * Draws a tunnel of bridge tile.

  * For tunnels, this is rather simple, as you only needa draw the entrance.

  * Bridges are a bit more complex. base_offset is where the sprite selection comes into play

  * and it works a bit like a bitmask.<p> For bridge heads:

	int i = 0;

	if (y >= v->y_pos) {

		if (y != v->y_pos) i+=3;

		i+=3;

	}

	if (x >= v->x_pos) {

		if (x != v->x_pos) i++;

		i++;

	}

	dir = v->direction;

	dirdiff = _new_direction_table[i] - dir;

	if (dirdiff == 0)

		return dir;

	return (dir+((dirdiff&7)<5?1:-1)) & 7;

}

Trackdir GetVehicleTrackdir(const Vehicle* v)

{

	if (v->vehstatus & VS_CRASHED) return 0xFF;

		case VEH_Train:

			if (v->u.rail.track == 0x80) /* We'll assume the train is facing outwards */

				return DiagdirToDiagTrackdir(GetDepotDirection(v->tile, TRANSPORT_RAIL)); /* Train in depot */