static const uint16 _is_upwards_slope[15] = {

	0, // no tileh

	0, // 5

	0, // 7

	0, //10

	0, //11,

	0, //13

	0, //14

};

 * track entering in this direction (including those making 90 degree turns)

 */

const TrackdirBits _exitdir_reaches_trackdirs[] = {

};

const Trackdir _next_trackdir[] = {

};

/* Maps a trackdir to all trackdirs that make 90 deg turns with it. */

const TrackdirBits _track_crosses_trackdirs[] = {

	TRACKDIR_BIT_RIGHT_N  | TRACKDIR_BIT_RIGHT_S  | TRACKDIR_BIT_LEFT_N  | TRACKDIR_BIT_LEFT_S,  /* TRACK_UPPER */

	TRACKDIR_BIT_RIGHT_N  | TRACKDIR_BIT_RIGHT_S  | TRACKDIR_BIT_LEFT_N  | TRACKDIR_BIT_LEFT_S,  /* TRACK_LOWER */

	TRACKDIR_BIT_UPPER_W  | TRACKDIR_BIT_UPPER_E  | TRACKDIR_BIT_LOWER_W | TRACKDIR_BIT_LOWER_E, /* TRACK_LEFT  */

/* Maps a track to all tracks that make 90 deg turns with it. */

const TrackBits _track_crosses_tracks[] = {

	TRACK_BIT_LEFT  | TRACK_BIT_RIGHT, /* TRACK_UPPER */

	TRACK_BIT_LEFT  | TRACK_BIT_RIGHT, /* TRACK_LOWER */

	TRACK_BIT_UPPER | TRACK_BIT_LOWER, /* TRACK_LEFT  */

};

const Trackdir _track_exitdir_to_trackdir[][DIAGDIR_END] = {

	{TRACKDIR_UPPER_E,  INVALID_TRACKDIR,  INVALID_TRACKDIR,  TRACKDIR_UPPER_W},

	{INVALID_TRACKDIR,  TRACKDIR_LOWER_E,  TRACKDIR_LOWER_W,  INVALID_TRACKDIR},

	{INVALID_TRACKDIR,  INVALID_TRACKDIR,  TRACKDIR_LEFT_S,   TRACKDIR_LEFT_N},

};

const Trackdir _track_enterdir_to_trackdir[][DIAGDIR_END] = { // TODO: replace magic with enums

	{INVALID_TRACKDIR,  TRACKDIR_UPPER_E,  TRACKDIR_UPPER_W,  INVALID_TRACKDIR},

	{TRACKDIR_LOWER_E,  INVALID_TRACKDIR,  INVALID_TRACKDIR,  TRACKDIR_LOWER_W},

	{TRACKDIR_LEFT_N,   TRACKDIR_LEFT_S,   INVALID_TRACKDIR,  INVALID_TRACKDIR},

};

const Trackdir _track_direction_to_trackdir[][DIR_END] = {

	{INVALID_TRACKDIR, INVALID_TRACKDIR,  TRACKDIR_UPPER_E, INVALID_TRACKDIR,  INVALID_TRACKDIR, INVALID_TRACKDIR,  TRACKDIR_UPPER_W, INVALID_TRACKDIR},

	{INVALID_TRACKDIR, INVALID_TRACKDIR,  TRACKDIR_LOWER_E, INVALID_TRACKDIR,  INVALID_TRACKDIR, INVALID_TRACKDIR,  TRACKDIR_LOWER_W, INVALID_TRACKDIR},

	{TRACKDIR_LEFT_N,  INVALID_TRACKDIR,  INVALID_TRACKDIR, INVALID_TRACKDIR,  TRACKDIR_LEFT_S,  INVALID_TRACKDIR,  INVALID_TRACKDIR, INVALID_TRACKDIR},

};

const Trackdir _dir_to_diag_trackdir[] = {

};

const DiagDirection _reverse_diagdir[] = {

};

const Trackdir _reverse_trackdir[] = {

};

RailType GetTileRailType(TileIndex tile, Trackdir trackdir)

/** These are used to specify a single track. Can be translated to a trackbit

 * with TrackToTrackbit */

typedef enum Tracks {

	TRACK_UPPER = 2,

	TRACK_LOWER = 3,

	TRACK_LEFT  = 4,

/** These are the bitfield variants of the above */

typedef enum TrackBits {

	TRACK_BIT_UPPER = 4U,    // 2

	TRACK_BIT_LOWER = 8U,    // 3

	TRACK_BIT_LEFT  = 16U,   // 4

/** These are a combination of tracks and directions. Values are 0-5 in one

direction (corresponding to the Track enum) and 8-13 in the other direction. */

typedef enum Trackdirs {

	TRACKDIR_UPPER_E  = 2,

	TRACKDIR_LOWER_E  = 3,

	TRACKDIR_LEFT_S   = 4,

	TRACKDIR_RIGHT_S  = 5,

	/* Note the two missing values here. This enables trackdir -> track

	 * conversion by doing (trackdir & 7) */

	TRACKDIR_UPPER_W  = 10,

	TRACKDIR_LOWER_W  = 11,

	TRACKDIR_LEFT_N   = 12,

/** These are a combination of tracks and directions. Values are 0-5 in one

direction (corresponding to the Track enum) and 8-13 in the other direction. */

typedef enum TrackdirBits {

	TRACKDIR_BIT_UPPER_E  = 0x4,

	TRACKDIR_BIT_LOWER_E  = 0x8,

	TRACKDIR_BIT_LEFT_S   = 0x10,

	TRACKDIR_BIT_RIGHT_S  = 0x20,

	/* Again, note the two missing values here. This enables trackdir -> track conversion by doing (trackdir & 0xFF) */

	TRACKDIR_BIT_UPPER_W  = 0x0400,

	TRACKDIR_BIT_LOWER_W  = 0x0800,

	TRACKDIR_BIT_LEFT_N   = 0x1000,

}

/* Checks if a given Track is diagonal */

/* Checks if a given Trackdir is diagonal. */

static inline bool IsDiagonalTrackdir(Trackdir trackdir) { return IsDiagonalTrack(TrackdirToTrack(trackdir)); }

{

	/* XXX: Nicer way to write this? */

	switch (track) {

			return (HASBIT(_m[tile].m5, 3) ? TRANSPORT_RAIL : TRANSPORT_ROAD);

			return (HASBIT(_m[tile].m5, 3) ? TRANSPORT_ROAD : TRANSPORT_RAIL);

		default:

			assert(0);

// set of normal ones

{

	TRACK_BIT_RIGHT,

	TRACK_BIT_UPPER,

	TRACK_BIT_LEFT,

	0,

	TRACK_BIT_LOWER,

	TRACK_BIT_LOWER,

	0,

	TRACK_BIT_LEFT,

	TRACK_BIT_UPPER,

	TRACK_BIT_RIGHT,

},

	0,

	TRACK_BIT_LEFT,

	TRACK_BIT_LOWER,

	TRACK_BIT_RIGHT,

	TRACK_BIT_UPPER,

},

// allowed rail on coast tile

	0,

	TRACK_BIT_LEFT,

	TRACK_BIT_LOWER,

	TRACK_BIT_RIGHT,

	TRACK_BIT_UPPER,

	},

	// valid railway crossings on slopes

				(i += 2, tileh == 4) ||

				(i += 2, tileh == 8)

			) && (

			)) {

		return i + 15;

	} else {

			return 0;

		if ((~_valid_tileh_slopes[1][tileh] & rail_bits) == 0 || ( // whole tile is leveled up

					(tileh == 1 || tileh == 2 || tileh == 4 || tileh == 8)

				)) { // partly up

			if (existing != 0) {

	switch (GetTileType(tile)) {

		case MP_TUNNELBRIDGE:

			if ((m5 & 0xC0) != 0xC0 || // not bridge middle part?

				// Get detailed error message

				return DoCommandByTile(tile, 0, 0, flags, CMD_LANDSCAPE_CLEAR);

			}

			if (!EnsureNoVehicle(tile)) return CMD_ERROR;

			if (GetRoadType(tile) == ROAD_NORMAL && (

					)) {

				if (flags & DC_EXEC) {

				}

				break;

			}

				return_cmd_error(STR_1007_ALREADY_BUILT);

			/* FALLTHROUGH */

			if ((_m[tile].m5 & 0xF8) != 0xE0)

				return CMD_ERROR;

				return CMD_ERROR;

			if (!(flags & DC_EXEC))

			/* This is a crossing, let's check if the direction is correct */

			if (_m[tile].m5 & 8) {

				bits = ROAD_Y;

			} else {

				bits = ROAD_X;

			}

	switch (GetRailTileType(tile)) {

		/* XXX: Why the fuck do we remove these thow signals first? */

		case RAIL_TYPE_SIGNALS:

				if (CmdFailed(ret)) return CMD_ERROR;

				cost += ret;

			}

	bool junction = false;

	// Select the sprite to use.

	(image++,                           track == TRACK_BIT_UPPER) ||

	(image++,                           track == TRACK_BIT_LOWER) ||

	(image++,                           track == TRACK_BIT_RIGHT) ||

	(image++,                           track == TRACK_BIT_LEFT) ||

	(image = rti->base_sprites.track_ns, track == (TRACK_BIT_UPPER | TRACK_BIT_LOWER)) ||

	(image++,                            track == (TRACK_BIT_LEFT | TRACK_BIT_RIGHT)) ||

	(junction = true, false) ||

	(image++, true);

	if (ti->tileh != 0) {

	// Draw track pieces individually for junction tiles

	if (junction) {

		if (track & TRACK_BIT_UPPER) DrawGroundSprite(rti->base_sprites.single_n);

		if (track & TRACK_BIT_LOWER) DrawGroundSprite(rti->base_sprites.single_s);

		if (track & TRACK_BIT_LEFT)  DrawGroundSprite(rti->base_sprites.single_w);

#define ISON_SIGNAL(x) (m23 & (byte)(0x10 << (x)))

#define MAYBE_DRAW_SIGNAL(x,y,z) if (HAS_SIGNAL(x)) DrawSignalHelper(ti, ISON_SIGNAL(x), ((y-0x4FB) << 4)|(z))

				if (m5 & TRACK_BIT_LEFT) {

					MAYBE_DRAW_SIGNAL(2, 0x509, 0);

					MAYBE_DRAW_SIGNAL(3, 0x507, 1);

				PlayerID owner = GetTileOwner(tile);

				if (rail == (TRACK_BIT_LOWER | TRACK_BIT_RIGHT) || (

						)) {

					TileIndex n = tile + TileDiffXY(0, -1);

				}

				if (rail == (TRACK_BIT_UPPER | TRACK_BIT_LEFT) || (

						)) {

					TileIndex n = tile + TileDiffXY(0, 1);

				}

				if (rail == (TRACK_BIT_LOWER | TRACK_BIT_LEFT) || (

						)) {

					TileIndex n = tile + TileDiffXY(-1, 0);

				}

				if (rail == (TRACK_BIT_UPPER | TRACK_BIT_RIGHT) || (

						)) {

					TileIndex n = tile + TileDiffXY(1, 0);

static inline TrackBits GetRailWaypointBits(TileIndex t)

{

}

					if (!(ti.map5 & 8)) {

						if (pieces & ROAD_Y) goto return_error;

					} else {

						if (pieces & ROAD_X) goto return_error;

					}

					cost = _price.remove_road * 2;

		st->build_date = _date;

		tile_delta = direction ? TileDiffXY(0, 1) : TileDiffXY(1, 0);

		statspec = (p2 & 0x10) != 0 ? GetCustomStation(STAT_CLASS_DFLT, p2 >> 8) : NULL;

		layout_ptr = alloca(numtracks * plat_len);

	// if we reached here, it means we can actually delete it. do that.

	if (flags & DC_EXEC) {

		DoClearSquare(tile);

		SetSignalsOnBothDir(tile, track);

		// now we need to make the "spanned" area of the railway station smaller if we deleted something at the edges.

				if (!EnsureNoVehicle(tile))

					return CMD_ERROR;

				if (flags & DC_EXEC) {

					DoClearSquare(tile);

					SetSignalsOnBothDir(tile, track);

				}

	if (p1 >= GetNumCustomStations(STAT_CLASS_WAYP)) return CMD_ERROR;

	if (!IsTileType(tile, MP_RAILWAY) || (

			)) {

		return_cmd_error(STR_1005_NO_SUITABLE_RAILROAD_TRACK);

	}