--- a/src/yapf/follow_track.hpp
+++ b/src/yapf/follow_track.hpp
@@ -252,7 +252,7 @@
 
 public:
 	/** Helper for pathfinders - get min/max speed on the m_old_tile/m_old_td */
-	int GetSpeedLimit(int *pmin_speed = NULL)
+	int GetSpeedLimit(int *pmin_speed = NULL) const
 	{
 		int min_speed = 0;
 		int max_speed = INT_MAX; // no limit

--- a/src/yapf/yapf_base.hpp
+++ b/src/yapf/yapf_base.hpp
@@ -213,7 +213,7 @@
 			m_stats_cache_hits++;
 		}
 
-		bool bValid = Yapf().PfCalcCost(n, tf);
+		bool bValid = Yapf().PfCalcCost(n, &tf);
 
 		if (bCached) {
 			Yapf().PfNodeCacheFlush(n);

--- a/src/yapf/yapf_costrail.hpp
+++ b/src/yapf/yapf_costrail.hpp
@@ -19,8 +19,43 @@
 	typedef typename Node::CachedData CachedData;
 
 protected:
+
+	/* Structure used inside PfCalcCost() to keep basic tile information. */
+	struct TILE {
+		TileIndex   tile;
+		Trackdir    td;
+		TileType    tile_type;
+		RailType    rail_type;
+
+		TILE()
+		{
+			tile = INVALID_TILE;
+			td = INVALID_TRACKDIR;
+			tile_type = MP_VOID;
+			rail_type = INVALID_RAILTYPE;
+		}
+
+		TILE(TileIndex tile, Trackdir td)
+		{
+			this->tile = tile;
+			this->td = td;
+			this->tile_type = GetTileType(tile);
+			this->rail_type = GetTileRailType(tile);
+		}
+
+		TILE(const TILE &src)
+		{
+			tile = src.tile;
+			td = src.td;
+			tile_type = src.tile_type;
+			rail_type = src.rail_type;
+		}
+	};
+
+protected:
 	int           m_max_cost;
 	CBlobT<int>   m_sig_look_ahead_costs;
+
 public:
 	bool          m_stopped_on_first_two_way_signal;
 protected:
@@ -65,8 +100,8 @@
 		return cost;
 	}
 
-	/** return one tile cost. If tile is a tunnel entry, it is moved to the end of tunnel */
-	FORCEINLINE int OneTileCost(TileIndex prev_tile, TileIndex& tile, Trackdir trackdir)
+	/** Return one tile cost (base cost + level crossing penalty). */
+	FORCEINLINE int OneTileCost(TileIndex& tile, Trackdir trackdir)
 	{
 		int cost = 0;
 		// set base cost
@@ -99,7 +134,7 @@
 			bool has_signal_along = HasSignalOnTrackdir(tile, trackdir);
 			if (has_signal_against && !has_signal_along) {
 				// one-way signal in opposite direction
-				n.m_segment->flags_u.flags_s.m_end_of_line = true;
+				n.m_segment->m_end_segment_reason |= ESRB_DEAD_END;
 			} else if (has_signal_along) {
 				SignalState sig_state = GetSignalStateByTrackdir(tile, trackdir);
 				// cache the look-ahead polynomial constant only if we didn't pass more signals than the look-ahead limit is
@@ -117,7 +152,7 @@
 					// was it first signal which is two-way?
 					if (Yapf().TreatFirstRedTwoWaySignalAsEOL() && n.flags_u.flags_s.m_choice_seen && has_signal_against && n.m_num_signals_passed == 0) {
 						// yes, the first signal is two-way red signal => DEAD END
-						n.m_segment->flags_u.flags_s.m_end_of_line = true;
+						n.m_segment->m_end_segment_reason |= ESRB_DEAD_END;
 						Yapf().m_stopped_on_first_two_way_signal = true;
 						return -1;
 					}
@@ -170,182 +205,241 @@
 public:
 	FORCEINLINE void SetMaxCost(int max_cost) {m_max_cost = max_cost;}
 
+
+
 	/** Called by YAPF to calculate the cost from the origin to the given node.
 	 *  Calculates only the cost of given node, adds it to the parent node cost
 	 *  and stores the result into Node::m_cost member */
-	FORCEINLINE bool PfCalcCost(Node &n, const TrackFollower &tf)
+	FORCEINLINE bool PfCalcCost(Node &n, const TrackFollower *tf)
 	{
 		assert(!n.flags_u.flags_s.m_targed_seen);
+		assert(tf->m_new_tile == n.m_key.m_tile);
+		assert((TrackdirToTrackdirBits(n.m_key.m_td) & tf->m_new_td_bits) != TRACKDIR_BIT_NONE);
+
 		CPerfStart perf_cost(Yapf().m_perf_cost);
-		int parent_cost = (n.m_parent != NULL) ? n.m_parent->m_cost : 0;
-		int first_tile_cost = 0;
+
+		/* Does the node have some parent node? */
+		bool has_parent = (n.m_parent != NULL);
+
+		/* Do we already have a cached segment? */
+		CachedData &segment = *n.m_segment;
+		bool is_cached_segment = (segment.m_cost >= 0);
+
+		int parent_cost = has_parent ? n.m_parent->m_cost : 0;
+
+		/* Each node cost contains 2 or 3 main components:
+		 *  1. Transition cost - cost of the move from previous node (tile):
+		 *    - curve cost (or zero for straight move)
+		 *  2. Tile cost:
+		 *    - base tile cost
+		 *      - YAPF_TILE_LENGTH for diagonal tiles
+		 *      - YAPF_TILE_CORNER_LENGTH for non-diagonal tiles
+		 *    - tile penalties
+		 *      - tile slope penalty (upward slopes)
+		 *      - red signal penalty
+		 *      - level crossing penalty
+		 *      - speed-limit penalty (bridges)
+		 *      - station platform penalty
+		 *      - penalty for reversing in the depot
+		 *      - etc.
+		 *  3. Extra cost (applies to the last node only)
+		 *    - last red signal penalty
+		 *    - penalty for too long or too short platform on the destination station
+		 */
+		int transition_cost = 0;
+		int tile_cost = 0;
+		int extra_cost = 0;
+
+		/* Segment: one or more tiles connected by contiguous tracks of the same type.
+		 * Each segment cost includes 'Tile cost' for all its tiles (including the first
+		 * and last), and the 'Transition cost' between its tiles. The first transition
+		 * cost of segment entry (move from the 'parent' node) is not included!
+		 */
+		int segment_entry_cost = 0;
 		int segment_cost = 0;
-		int extra_cost = 0;
+
 		const Vehicle* v = Yapf().GetVehicle();
 
 		// start at n.m_key.m_tile / n.m_key.m_td and walk to the end of segment
-		TileIndex prev_tile      = (n.m_parent != NULL) ? n.m_parent->GetLastTile() : INVALID_TILE;
-		Trackdir  prev_trackdir  = (n.m_parent != NULL) ? n.m_parent->GetLastTrackdir() : INVALID_TRACKDIR;
-		TileType  prev_tile_type = (n.m_parent != NULL) ? GetTileType(n.m_parent->GetLastTile()) : MP_VOID;
+		TILE cur(n.m_key.m_tile, n.m_key.m_td);
 
-		TileIndex tile = n.m_key.m_tile;
-		Trackdir trackdir = n.m_key.m_td;
-		TileType tile_type = GetTileType(tile);
+		// the previous tile will be needed for transition cost calculations
+		TILE prev = has_parent ? TILE() : TILE(n.m_parent->GetLastTile(), n.m_parent->GetLastTrackdir());
+
+		EndSegmentReasonBits end_segment_reason = ESRB_NONE;
 
-		RailType rail_type = GetTileRailType(tile);
+		TrackFollower tf_local(v, &Yapf().m_perf_ts_cost);
 
-		bool target_seen = Yapf().PfDetectDestination(tile, trackdir);
-		bool end_by_target_seen = false;
-
-		if (tf.m_is_station) {
-			// station tiles have an extra penalty
-			segment_cost += Yapf().PfGetSettings().rail_station_penalty * (tf.m_tiles_skipped + 1);
+		if (!has_parent) {
+			/* We will jump to the middle of the cost calculator assuming that segment cache is not used. */
+			assert(!is_cached_segment);
+			/* Skip the first transition cost calculation. */
+			goto no_entry_cost;
 		}
 
-		while (true) {
-			segment_cost += Yapf().OneTileCost(prev_tile, tile, trackdir);
-			segment_cost += Yapf().CurveCost(prev_trackdir, trackdir);
-			segment_cost += Yapf().SlopeCost(tile, trackdir);
-			segment_cost += Yapf().SignalCost(n, tile, trackdir);
-			if (n.m_segment->flags_u.flags_s.m_end_of_line) {
-				break;
+		for (;;) {
+			/* Transition cost (cost of the move from previous tile) */
+			transition_cost = Yapf().CurveCost(prev.td, cur.td);
+
+			/* First transition cost counts against segment entry cost, other transitions
+			 * inside segment will come to segment cost (and will be cached) */
+			if (segment_cost == 0) {
+				/* We just entered the loop. First transition cost goes to segment entry cost)*/
+				segment_entry_cost = transition_cost;
+				transition_cost = 0;
+
+				/* It is the right time now to look if we can reuse the cached segment cost. */
+				if (is_cached_segment) {
+					/* Yes, we already know the segment cost. */
+					segment_cost = segment.m_cost;
+					/* We know also the reason why the segment ends. */
+					end_segment_reason = segment.m_end_segment_reason;
+					/* No further calculation needed. */
+					cur = TILE(n.GetLastTile(), n.GetLastTrackdir());
+					break;
+				}
+			} else {
+				/* Other than first transition cost count as the regular segment cost. */
+				segment_cost += transition_cost;
 			}
 
-			// finish if we have reached the destination
-			if (target_seen) {
-				end_by_target_seen = true;
-				break;
-			}
+no_entry_cost: // jump here at the beginning if the node has no parent (it is the first node)
+
+			/* All other tile costs will be calculated here. */
+			segment_cost += Yapf().OneTileCost(cur.tile, cur.td);
+
+			/* If we skipped some tunnel/bridge/station tiles, add their base cost */
+			segment_cost += YAPF_TILE_LENGTH * tf->m_tiles_skipped;
+
+			/* Slope cost. */
+			segment_cost += Yapf().SlopeCost(cur.tile, cur.td);
+
+			/* Signal cost (routine can modify segment data). */
+			segment_cost += Yapf().SignalCost(n, cur.tile, cur.td);
+			end_segment_reason = segment.m_end_segment_reason;
 
-			// finish on first station tile - segment should end here to avoid target skipping
-			// when cached segments are used
-			if (tile_type == MP_STATION && prev_tile_type != MP_STATION) {
-				break;
+			/* Tests for 'potential target' reasons to close the segment. */
+			if (cur.tile == prev.tile) {
+				/* Penalty for reversing in a depot. */
+				assert(IsRailDepot(cur.tile));
+				segment_cost += Yapf().PfGetSettings().rail_depot_reverse_penalty;
+				/* We will end in this pass (depot is possible target) */
+				end_segment_reason |= ESRB_DEPOT;
+
+			} else if (tf->m_is_station) {
+				/* Station penalties. */
+				uint platform_length = tf->m_tiles_skipped + 1;
+				/* We don't know yet if the station is our target or not. Act like
+				 * if it is pass-through station (not our destination). */
+				segment_cost += Yapf().PfGetSettings().rail_station_penalty * platform_length;
+				/* We will end in this pass (station is possible target) */
+				end_segment_reason |= ESRB_STATION;
+
+			} else if (cur.tile_type == MP_RAILWAY && IsRailWaypoint(cur.tile)) {
+				/* Waypoint is also a good reason to finish. */
+				end_segment_reason |= ESRB_WAYPOINT;
 			}
 
-			// finish also on waypoint - same workaround as for first station tile
-			if (tile_type == MP_RAILWAY && IsRailWaypoint(tile)) {
-				break;
+			/* Apply min/max speed penalties only when inside the look-ahead radius. Otherwise
+			 * it would cause desync in MP. */
+			if (n.m_num_signals_passed < m_sig_look_ahead_costs.Size())
+			{
+				int min_speed = 0;
+				int max_speed = tf->GetSpeedLimit(&min_speed);
+				if (max_speed < v->max_speed)
+					extra_cost += YAPF_TILE_LENGTH * (v->max_speed - max_speed) * (4 + tf->m_tiles_skipped) / v->max_speed;
+				if (min_speed > v->max_speed)
+					extra_cost += YAPF_TILE_LENGTH * (min_speed - v->max_speed);
 			}
 
-			// if there are no reachable trackdirs on the next tile, we have end of road
-			TrackFollower F(v, &Yapf().m_perf_ts_cost);
-			if (!F.Follow(tile, trackdir)) {
-				// we can't continue?
-				// n.m_segment->flags_u.flags_s.m_end_of_line = true;
-				break;
+			/* Finish if we already exceeded the maximum path cost (i.e. when
+			 * searching for the nearest depot). */
+			if (m_max_cost > 0 && (parent_cost + segment_entry_cost + segment_cost) > m_max_cost) {
+				end_segment_reason |= ESRB_PATH_TOO_LONG;
 			}
 
-			// if there are more trackdirs available & reachable, we are at the end of segment
-			if (KillFirstBit2x64(F.m_new_td_bits) != 0) {
+			/* Move to the next tile/trackdir. */
+			tf = &tf_local;
+			tf_local.Init(v, &Yapf().m_perf_ts_cost);
+
+			if (!tf_local.Follow(cur.tile, cur.td)) {
+				/* Can't move to the next tile (EOL?). */
+				end_segment_reason |= ESRB_DEAD_END;
 				break;
 			}
 
-			Trackdir new_td = (Trackdir)FindFirstBit2x64(F.m_new_td_bits);
-
-			{
-				// end segment if train is about to enter simple loop with no junctions
-				// so next time it should stop on the next if
-				if (segment_cost > s_max_segment_cost && IsTileType(F.m_new_tile, MP_RAILWAY))
-					break;
-
-				// stop if train is on simple loop with no junctions
-				if (F.m_new_tile == n.m_key.m_tile && new_td == n.m_key.m_td)
-					return false;
+			/* Check if the next tile is not a choice. */
+			if (KillFirstBit2x64(tf_local.m_new_td_bits) != 0) {
+				/* More than one segment will follow. Close this one. */
+				end_segment_reason |= ESRB_CHOICE_FOLLOWS;
+				break;
 			}
 
-			// if tail type changes, finish segment (cached segment can't contain more rail types)
-			{
-				RailType new_rail_type = GetTileRailType(F.m_new_tile);
-				if (new_rail_type != rail_type) {
-					break;
-				}
-				rail_type = new_rail_type;
+			/* Gather the next tile/trackdir/tile_type/rail_type. */
+			TILE next(tf_local.m_new_tile, (Trackdir)FindFirstBit2x64(tf_local.m_new_td_bits));
+
+			/* Check the next tile for the rail type. */
+			if (next.rail_type != cur.rail_type) {
+				/* Segment must consist from the same rail_type tiles. */
+				end_segment_reason |= ESRB_RAIL_TYPE;
+				break;
 			}
 
-			// move to the next tile
-			prev_tile = tile;
-			prev_trackdir = trackdir;
-			prev_tile_type = tile_type;
-
-			tile = F.m_new_tile;
-			trackdir = new_td;
-			tile_type = GetTileType(tile);
-
-			target_seen = Yapf().PfDetectDestination(tile, trackdir);
-
-			// reversing in depot penalty
-			if (tile == prev_tile) {
-				segment_cost += Yapf().PfGetSettings().rail_depot_reverse_penalty;
+			/* Avoid infinite looping. */
+			if (next.tile == n.m_key.m_tile && next.td == n.m_key.m_td) {
+				end_segment_reason |= ESRB_INFINITE_LOOP;
 				break;
 			}
 
-			// if we skipped some tunnel tiles, add their cost
-			segment_cost += YAPF_TILE_LENGTH * F.m_tiles_skipped;
-
-			// add penalty for skipped station tiles
-			if (F.m_is_station)
-			{
-				uint platform_length = F.m_tiles_skipped + 1;
-				if (target_seen) {
-					// it is our destination station
-					segment_cost += PlatformLengthPenalty(platform_length);
-				} else {
-					// station is not our destination station, apply penalty for skipped platform tiles
-					segment_cost += Yapf().PfGetSettings().rail_station_penalty * platform_length;
+			if (segment_cost > s_max_segment_cost) {
+				/* Potentially in the infinite loop (or only very long segment?). We should
+				 * not force it to finish prematurely unless we are on a regular tile. */
+				if (IsTileType(tf->m_new_tile, MP_RAILWAY)) {
+					end_segment_reason |= ESRB_SEGMENT_TOO_LONG;
+					break;
 				}
 			}
 
-			// add min/max speed penalties
-			int min_speed = 0;
-			int max_speed = F.GetSpeedLimit(&min_speed);
-			if (max_speed < v->max_speed)
-				segment_cost += YAPF_TILE_LENGTH * (v->max_speed - max_speed) / v->max_speed;
-			if (min_speed > v->max_speed)
-				segment_cost += YAPF_TILE_LENGTH * (min_speed - v->max_speed);
-
-			// finish if we already exceeded the maximum cost
-			if (m_max_cost > 0 && (parent_cost + first_tile_cost + segment_cost) > m_max_cost) {
-				return false;
+			/* Any other reason bit set? */
+			if (end_segment_reason != ESRB_NONE) {
+				break;
 			}
 
-			if (first_tile_cost == 0) {
-				// we just have done first tile
-				first_tile_cost = segment_cost;
-				segment_cost = 0;
+			/* For the next loop set new prev and cur tile info. */
+			prev = cur;
+			cur = next;
+
+		} // for (;;)
 
-				// look if we can reuse existing (cached) segment cost
-				if (n.m_segment->m_cost >= 0) {
-					// reuse the cached segment cost
-					break;
-				}
+		bool target_seen = false;
+		if ((end_segment_reason & ESRB_POSSIBLE_TARGET) != ESRB_NONE) {
+			/* Depot, station or waypoint. */
+			if (Yapf().PfDetectDestination(cur.tile, cur.td)) {
+				/* Destination found. */
+				target_seen = true;
 			}
-			// segment cost was not filled yes, we have not cached it yet
-			n.SetLastTileTrackdir(tile, trackdir);
-
-		} // while (true)
-
-		if (first_tile_cost == 0) {
-			// we have just finished first tile
-			first_tile_cost = segment_cost;
-			segment_cost = 0;
 		}
 
-		// do we have cached segment cost?
-		if (n.m_segment->m_cost >= 0) {
-			// reuse the cached segment cost
-			segment_cost = n.m_segment->m_cost;
-		} else {
-			// save segment cost
-			n.m_segment->m_cost = segment_cost;
-
-			// save end of segment back to the node
-			n.SetLastTileTrackdir(tile, trackdir);
+		/* Update the segment if needed. */
+		if (!is_cached_segment) {
+			/* Write back the segment information so it can be reused the next time. */
+			segment.m_cost = segment_cost;
+			segment.m_end_segment_reason = end_segment_reason & ESRB_CACHED_MASK;
+			assert(segment.m_end_segment_reason != ESRB_NONE);
+			/* Save end of segment back to the node. */
+			n.SetLastTileTrackdir(cur.tile, cur.td);
 		}
 
-		// special costs for the case we have reached our target
-		if (end_by_target_seen) {
+		/* Do we have an excuse why not to continue pathfinding in this direction? */
+		if (!target_seen && (end_segment_reason & ESRB_ABORT_PF_MASK) != ESRB_NONE) {
+			/* Reason to not continue. Stop this PF branch. */
+			return false;
+		}
+
+		/* Special costs for the case we have reached our target. */
+		if (target_seen) {
 			n.flags_u.flags_s.m_targed_seen = true;
+			/* Last-red and last-red-exit penalties. */
 			if (n.flags_u.flags_s.m_last_signal_was_red) {
 				if (n.m_last_red_signal_type == SIGTYPE_EXIT) {
 					// last signal was red pre-signal-exit
@@ -355,12 +449,23 @@
 					extra_cost += Yapf().PfGetSettings().rail_lastred_penalty;
 				}
 			}
+
+			/* Station platform-length penalty. */
+			if ((end_segment_reason & ESRB_STATION) != ESRB_NONE) {
+				Station *st = GetStationByTile(n.GetLastTile());
+				assert(st != NULL);
+				uint platform_length = st->GetPlatformLength(n.GetLastTile(), ReverseDiagDir(TrackdirToExitdir(n.GetLastTrackdir())));
+				/* Reduce the extra cost caused by passing-station penalty (each station receives it in the segment cost). */
+				extra_cost -= Yapf().PfGetSettings().rail_station_penalty * platform_length;
+				/* Add penalty for the inappropriate platform length. */
+				extra_cost += PlatformLengthPenalty(platform_length);
+			}
 		}
 
 		// total node cost
-		n.m_cost = parent_cost + first_tile_cost + segment_cost + extra_cost;
+		n.m_cost = parent_cost + segment_entry_cost + segment_cost + extra_cost;
 
-		return !n.m_segment->flags_u.flags_s.m_end_of_line || end_by_target_seen;
+		return true;
 	}
 
 	FORCEINLINE bool CanUseGlobalCache(Node& n) const

--- a/src/yapf/yapf_node_rail.hpp
+++ b/src/yapf/yapf_node_rail.hpp
@@ -22,6 +22,60 @@
 	FORCEINLINE bool operator == (const CYapfRailSegmentKey& other) const {return m_value == other.m_value;}
 };
 
+/* Enum used in PfCalcCost() to see why was the segment closed. */
+enum EndSegmentReason {
+	/* The following reasons can be saved into cached segment */
+	ESR_DEAD_END = 0,      ///< track ends here
+	ESR_RAIL_TYPE,         ///< the next tile has a different rail type than our tiles
+	ESR_INFINITE_LOOP,     ///< infinite loop detected
+	ESR_SEGMENT_TOO_LONG,  ///< the segment is too long (possible infinite loop)
+	ESR_CHOICE_FOLLOWS,    ///< the next tile contains a choice (the track splits to more than one segments)
+	ESR_DEPOT,             ///< stop in the depot (could be a target next time)
+	ESR_WAYPOINT,          ///< waypoint encountered (could be a target next time)
+	ESR_STATION,           ///< station encountered (could be a target next time)
+
+	/* The following reasons are used only internally by PfCalcCost().
+	*   They should not be found in the cached segment. */
+	ESR_PATH_TOO_LONG,     ///< the path is too long (searching for the nearest depot in the given radius)
+	ESR_FIRST_TWO_WAY_RED, ///< first signal was 2-way and it was red
+	ESR_LOOK_AHEAD_END,    ///< we have just passed the last look-ahead signal
+	ESR_TARGET_REACHED,    ///< we have just reached the destination
+
+	/* Special values */
+	ESR_NONE = 0xFF,          ///< no reason to end the segment here
+};
+
+enum EndSegmentReasonBits {
+	ESRB_NONE = 0,
+
+	ESRB_DEAD_END          = 1 << ESR_DEAD_END,
+	ESRB_RAIL_TYPE         = 1 << ESR_RAIL_TYPE,
+	ESRB_INFINITE_LOOP     = 1 << ESR_INFINITE_LOOP,
+	ESRB_SEGMENT_TOO_LONG  = 1 << ESR_SEGMENT_TOO_LONG,
+	ESRB_CHOICE_FOLLOWS    = 1 << ESR_CHOICE_FOLLOWS,
+	ESRB_DEPOT             = 1 << ESR_DEPOT,
+	ESRB_WAYPOINT          = 1 << ESR_WAYPOINT,
+	ESRB_STATION           = 1 << ESR_STATION,
+
+	ESRB_PATH_TOO_LONG     = 1 << ESR_PATH_TOO_LONG,
+	ESRB_FIRST_TWO_WAY_RED = 1 << ESR_FIRST_TWO_WAY_RED,
+	ESRB_LOOK_AHEAD_END    = 1 << ESR_LOOK_AHEAD_END,
+	ESRB_TARGET_REACHED    = 1 << ESR_TARGET_REACHED,
+
+	/* Additional (composite) values. */
+
+	/* What reasons mean that the target can be fond and needs to be detected. */
+	ESRB_POSSIBLE_TARGET = ESRB_DEPOT | ESRB_WAYPOINT | ESRB_STATION,
+
+	/* What reasons can be stored back into cached segment. */
+	ESRB_CACHED_MASK = ESRB_DEAD_END | ESRB_RAIL_TYPE | ESRB_INFINITE_LOOP | ESRB_SEGMENT_TOO_LONG | ESRB_CHOICE_FOLLOWS | ESRB_DEPOT | ESRB_WAYPOINT | ESRB_STATION,
+
+	/* Reasons to abort pathfinding in this direction. */
+	ESRB_ABORT_PF_MASK = ESRB_DEAD_END | ESRB_PATH_TOO_LONG | ESRB_INFINITE_LOOP | ESRB_FIRST_TWO_WAY_RED,
+};
+
+DECLARE_ENUM_AS_BIT_SET(EndSegmentReasonBits);
+
 /** cached segment cost for rail YAPF */
 struct CYapfRailSegment
 {
@@ -33,14 +87,8 @@
 	int                    m_cost;
 	TileIndex              m_last_signal_tile;
 	Trackdir               m_last_signal_td;
+	EndSegmentReasonBits   m_end_segment_reason;
 	CYapfRailSegment*      m_hash_next;
-	union {
-		byte                 m_flags;
-		struct {
-			bool                   m_end_of_line : 1;
-		} flags_s;
-	} flags_u;
-	byte m_reserve[3];
 
 	FORCEINLINE CYapfRailSegment(const CYapfRailSegmentKey& key)
 		: m_key(key)
@@ -49,10 +97,9 @@
 		, m_cost(-1)
 		, m_last_signal_tile(INVALID_TILE)
 		, m_last_signal_td(INVALID_TRACKDIR)
+		, m_end_segment_reason(ESRB_NONE)
 		, m_hash_next(NULL)
-	{
-		flags_u.m_flags = 0;
-	}
+	{}
 
 	FORCEINLINE const Key& GetKey() const {return m_key;}
 	FORCEINLINE TileIndex GetTile() const {return m_key.GetTile();}

--- a/src/yapf/yapf_road.cpp
+++ b/src/yapf/yapf_road.cpp
@@ -72,7 +72,7 @@
 	/** Called by YAPF to calculate the cost from the origin to the given node.
 	 *  Calculates only the cost of given node, adds it to the parent node cost
 	 *  and stores the result into Node::m_cost member */
-	FORCEINLINE bool PfCalcCost(Node& n, const TrackFollower &tf)
+	FORCEINLINE bool PfCalcCost(Node& n, const TrackFollower *tf)
 	{
 		int segment_cost = 0;
 		// start at n.m_key.m_tile / n.m_key.m_td and walk to the end of segment

--- a/src/yapf/yapf_ship.cpp
+++ b/src/yapf/yapf_ship.cpp
@@ -100,7 +100,7 @@
 	/** Called by YAPF to calculate the cost from the origin to the given node.
 	 *  Calculates only the cost of given node, adds it to the parent node cost
 	 *  and stores the result into Node::m_cost member */
-	FORCEINLINE bool PfCalcCost(Node& n, const TrackFollower &tf)
+	FORCEINLINE bool PfCalcCost(Node& n, const TrackFollower *tf)
 	{
 		// base tile cost depending on distance
 		int c = IsDiagonalTrackdir(n.GetTrackdir()) ? 10 : 7;