Index: src/water_map.h
===================================================================
--- src/water_map.h	(revision 19703)
+++ src/water_map.h	(working copy)
@@ -159,7 +159,7 @@
 	_m[t].m4 = 0;
 	_m[t].m5 = 1;
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 /**
@@ -178,7 +178,7 @@
 	_m[t].m4 = random_bits;
 	_m[t].m5 = 0;
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 /**
@@ -221,7 +221,7 @@
 	_m[t].m4 = 0;
 	_m[t].m5 = base + a * 2;
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 static inline void MakeLockTile(TileIndex t, Owner o, byte section, WaterClass original_water_class)
@@ -233,7 +233,7 @@
 	_m[t].m4 = 0;
 	_m[t].m5 = section;
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 static inline void MakeLock(TileIndex t, Owner o, DiagDirection d, WaterClass wc_lower, WaterClass wc_upper)
Index: src/town_map.h
===================================================================
--- src/town_map.h	(revision 19703)
+++ src/town_map.h	(working copy)
@@ -83,7 +83,7 @@
  */
 static inline bool LiftHasDestination(TileIndex t)
 {
-	return HasBit(_me[t].m7, 0);
+	return HasBit(_m[t].m7, 0);
 }
 
 /**
@@ -94,8 +94,8 @@
  */
 static inline void SetLiftDestination(TileIndex t, byte dest)
 {
-	SetBit(_me[t].m7, 0);
-	SB(_me[t].m7, 1, 3, dest);
+	SetBit(_m[t].m7, 0);
+	SB(_m[t].m7, 1, 3, dest);
 }
 
 /**
@@ -105,7 +105,7 @@
  */
 static inline byte GetLiftDestination(TileIndex t)
 {
-	return GB(_me[t].m7, 1, 3);
+	return GB(_m[t].m7, 1, 3);
 }
 
 /**
@@ -116,7 +116,7 @@
  */
 static inline void HaltLift(TileIndex t)
 {
-	SB(_me[t].m7, 0, 4, 0);
+	SB(_m[t].m7, 0, 4, 0);
 }
 
 /**
@@ -208,7 +208,7 @@
 	SetHouseCompleted(t, stage == TOWN_HOUSE_COMPLETED);
 	_m[t].m5 = IsHouseCompleted(t) ? 0 : (stage << 3 | counter);
 	SetHouseAnimationFrame(t, 0);
-	_me[t].m7 = HouseSpec::Get(type)->processing_time;
+	_m[t].m7 = HouseSpec::Get(type)->processing_time;
 }
 
 /**
@@ -365,7 +365,7 @@
 static inline byte GetHouseProcessingTime(TileIndex t)
 {
 	assert(IsTileType(t, MP_HOUSE));
-	return _me[t].m7;
+	return _m[t].m7;
 }
 
 /**
@@ -377,7 +377,7 @@
 static inline void SetHouseProcessingTime(TileIndex t, byte time)
 {
 	assert(IsTileType(t, MP_HOUSE));
-	_me[t].m7 = time;
+	_m[t].m7 = time;
 }
 
 /**
@@ -388,7 +388,7 @@
 static inline void DecHouseProcessingTime(TileIndex t)
 {
 	assert(IsTileType(t, MP_HOUSE));
-	_me[t].m7--;
+	_m[t].m7--;
 }
 
 #endif /* TOWN_MAP_H */
Index: src/misc_gui.cpp
===================================================================
--- src/misc_gui.cpp	(revision 19703)
+++ src/misc_gui.cpp	(working copy)
@@ -312,7 +312,7 @@
 		DEBUG(misc, LANDINFOD_LEVEL, "m4           = %#x", _m[tile].m4);
 		DEBUG(misc, LANDINFOD_LEVEL, "m5           = %#x", _m[tile].m5);
 		DEBUG(misc, LANDINFOD_LEVEL, "m6           = %#x", _m[tile].m6);
-		DEBUG(misc, LANDINFOD_LEVEL, "m7           = %#x", _me[tile].m7);
+		DEBUG(misc, LANDINFOD_LEVEL, "m7           = %#x", _m[tile].m7);
 #undef LANDINFOD_LEVEL
 	}
 };
Index: src/unmovable_map.h
===================================================================
--- src/unmovable_map.h	(revision 19703)
+++ src/unmovable_map.h	(working copy)
@@ -199,7 +199,7 @@
 	_m[t].m4 = 0;
 	_m[t].m5 = u;
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 
Index: src/tree_map.h
===================================================================
--- src/tree_map.h	(revision 19703)
+++ src/tree_map.h	(working copy)
@@ -283,7 +283,7 @@
 	_m[t].m4 = 0 << 5 | 0 << 2;
 	_m[t].m5 = count << 6 | growth;
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 #endif /* TREE_MAP_H */
Index: src/void_map.h
===================================================================
--- src/void_map.h	(revision 19703)
+++ src/void_map.h	(working copy)
@@ -28,7 +28,7 @@
 	_m[t].m4 = 0;
 	_m[t].m5 = 0;
 	_m[t].m6 = 0;
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 #endif /* VOID_MAP_H */
Index: src/map_func.h
===================================================================
--- src/map_func.h	(revision 19703)
+++ src/map_func.h	(working copy)
@@ -36,14 +36,6 @@
 extern Tile *_m;
 
 /**
- * Pointer to the extended tile-array.
- *
- * This variable points to the extended tile-array which contains the tiles
- * of the map.
- */
-extern TileExtended *_me;
-
-/**
  * Allocate a new map with the given size.
  */
 void AllocateMap(uint size_x, uint size_y);
Index: src/map_type.h
===================================================================
--- src/map_type.h	(revision 19703)
+++ src/map_type.h	(working copy)
@@ -24,17 +24,10 @@
 	byte   m4;          ///< General purpose
 	byte   m5;          ///< General purpose
 	byte   m6;          ///< Primarily used for bridges and rainforest/desert
+	byte   m7;			///< Primarily used for newgrf support
 };
 
 /**
- * Data that is stored per tile. Also used Tile for this.
- * Look at docs/landscape.html for the exact meaning of the members.
- */
-struct TileExtended {
-	byte m7; ///< Primarily used for newgrf support
-};
-
-/**
  * An offset value between to tiles.
  *
  * This value is used fro the difference between
Index: src/clear_map.h
===================================================================
--- src/clear_map.h	(revision 19703)
+++ src/clear_map.h	(working copy)
@@ -283,7 +283,7 @@
 	_m[t].m4 = 0 << 5 | 0 << 2;
 	SetClearGroundDensity(t, g, density); // Sets m5
 	SB(_m[t].m6, 2, 4, 0); // Other bits are "tropic zone" and "bridge above"
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 
@@ -302,7 +302,7 @@
 	_m[t].m4 = 0 << 5 | 0 << 2;
 	SetClearGroundDensity(t, CLEAR_FIELDS, 3);
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 /**
Index: src/industry_map.h
===================================================================
--- src/industry_map.h	(revision 19703)
+++ src/industry_map.h	(working copy)
@@ -261,7 +261,7 @@
 static inline byte GetIndustryRandomBits(TileIndex tile)
 {
 	assert(IsTileType(tile, MP_INDUSTRY));
-	return _me[tile].m7;
+	return _m[tile].m7;
 }
 
 /**
@@ -274,7 +274,7 @@
 static inline void SetIndustryRandomBits(TileIndex tile, byte bits)
 {
 	assert(IsTileType(tile, MP_INDUSTRY));
-	_me[tile].m7 = bits;
+	_m[tile].m7 = bits;
 }
 
 /**
Index: src/road_map.h
===================================================================
--- src/road_map.h	(revision 19703)
+++ src/road_map.h	(working copy)
@@ -106,13 +106,13 @@
 
 static inline RoadTypes GetRoadTypes(TileIndex t)
 {
-	return (RoadTypes)GB(_me[t].m7, 6, 2);
+	return (RoadTypes)GB(_m[t].m7, 6, 2);
 }
 
 static inline void SetRoadTypes(TileIndex t, RoadTypes rt)
 {
 	assert(IsTileType(t, MP_ROAD) || IsTileType(t, MP_STATION) || IsTileType(t, MP_TUNNELBRIDGE));
-	SB(_me[t].m7, 6, 2, rt);
+	SB(_m[t].m7, 6, 2, rt);
 }
 
 static inline bool HasTileRoadType(TileIndex t, RoadType rt)
@@ -124,7 +124,7 @@
 {
 	switch (rt) {
 		default: NOT_REACHED();
-		case ROADTYPE_ROAD: return (Owner)GB(IsNormalRoadTile(t) ? _m[t].m1 : _me[t].m7, 0, 5);
+		case ROADTYPE_ROAD: return (Owner)GB(IsNormalRoadTile(t) ? _m[t].m1 : _m[t].m7, 0, 5);
 		case ROADTYPE_TRAM: {
 			/* Trams don't need OWNER_TOWN, and remapping OWNER_NONE
 			 * to OWNER_TOWN makes it use one bit less */
@@ -138,7 +138,7 @@
 {
 	switch (rt) {
 		default: NOT_REACHED();
-		case ROADTYPE_ROAD: SB(IsNormalRoadTile(t) ? _m[t].m1 : _me[t].m7, 0, 5, o); break;
+		case ROADTYPE_ROAD: SB(IsNormalRoadTile(t) ? _m[t].m1 : _m[t].m7, 0, 5, o); break;
 		case ROADTYPE_TRAM: SB(_m[t].m3, 4, 4, o == OWNER_NONE ? OWNER_TOWN : o); break;
 	}
 }
@@ -282,13 +282,13 @@
 #define IsOnDesert IsOnSnow
 static inline bool IsOnSnow(TileIndex t)
 {
-	return HasBit(_me[t].m7, 5);
+	return HasBit(_m[t].m7, 5);
 }
 
 #define ToggleDesert ToggleSnow
 static inline void ToggleSnow(TileIndex t)
 {
-	ToggleBit(_me[t].m7, 5);
+	ToggleBit(_m[t].m7, 5);
 }
 
 
@@ -319,9 +319,9 @@
 
 static inline bool IncreaseRoadWorksCounter(TileIndex t)
 {
-	AB(_me[t].m7, 0, 4, 1);
+	AB(_m[t].m7, 0, 4, 1);
 
-	return GB(_me[t].m7, 0, 4) == 15;
+	return GB(_m[t].m7, 0, 4) == 15;
 }
 
 static inline void StartRoadWorks(TileIndex t)
@@ -340,7 +340,7 @@
 	assert(HasRoadWorks(t));
 	SetRoadside(t, (Roadside)(GetRoadside(t) - ROADSIDE_GRASS_ROAD_WORKS + ROADSIDE_GRASS));
 	/* Stop the counter */
-	SB(_me[t].m7, 0, 4, 0);
+	SB(_m[t].m7, 0, 4, 0);
 }
 
 
@@ -379,7 +379,7 @@
 	_m[t].m4 = 0;
 	_m[t].m5 = (HasBit(rot, ROADTYPE_ROAD) ? bits : 0) | ROAD_TILE_NORMAL << 6;
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = rot << 6;
+	_m[t].m7 = rot << 6;
 	SetRoadOwner(t, ROADTYPE_TRAM, tram);
 }
 
@@ -393,7 +393,7 @@
 	_m[t].m4 = 0;
 	_m[t].m5 = ROAD_TILE_CROSSING << 6 | roaddir;
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = rot << 6 | road;
+	_m[t].m7 = rot << 6 | road;
 	SetRoadOwner(t, ROADTYPE_TRAM, tram);
 }
 
@@ -407,7 +407,7 @@
 	_m[t].m4 = 0;
 	_m[t].m5 = ROAD_TILE_DEPOT << 6 | dir;
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = RoadTypeToRoadTypes(rt) << 6 | owner;
+	_m[t].m7 = RoadTypeToRoadTypes(rt) << 6 | owner;
 	SetRoadOwner(t, ROADTYPE_TRAM, owner);
 }
 
Index: src/map.cpp
===================================================================
--- src/map.cpp	(revision 19703)
+++ src/map.cpp	(working copy)
@@ -28,7 +28,6 @@
 uint _map_tile_mask; ///< _map_size - 1 (to mask the mapsize)
 
 Tile *_m = NULL;          ///< Tiles of the map
-TileExtended *_me = NULL; ///< Extended Tiles of the map
 
 
 /*!
@@ -56,10 +55,8 @@
 	_map_tile_mask = _map_size - 1;
 
 	free(_m);
-	free(_me);
 
 	_m = CallocT<Tile>(_map_size);
-	_me = CallocT<TileExtended>(_map_size);
 }
 
 
Index: src/saveload/oldloader_sl.cpp
===================================================================
--- src/saveload/oldloader_sl.cpp	(revision 19703)
+++ src/saveload/oldloader_sl.cpp	(working copy)
@@ -1455,7 +1455,7 @@
 {
 	if (_savegame_type == SGT_TTO) {
 		MemSetT(_m, 0, OLD_MAP_SIZE);
-		MemSetT(_me, 0, OLD_MAP_SIZE);
+		MemSetT(_m, 0, OLD_MAP_SIZE);
 	}
 
 	for (uint i = 0; i < OLD_MAP_SIZE; i++) {
Index: src/saveload/afterload.cpp
===================================================================
--- src/saveload/afterload.cpp	(revision 19703)
+++ src/saveload/afterload.cpp	(working copy)
@@ -887,12 +887,12 @@
 		for (TileIndex t = 0; t < map_size; t++) {
 			switch (GetTileType(t)) {
 				case MP_ROAD:
-					if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_me[t].m7, 5, 3));
-					SB(_me[t].m7, 5, 1, GB(_m[t].m3, 7, 1)); // snow/desert
+					if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_m[t].m7, 5, 3));
+					SB(_m[t].m7, 5, 1, GB(_m[t].m3, 7, 1)); // snow/desert
 					switch (GetRoadTileType(t)) {
 						default: NOT_REACHED();
 						case ROAD_TILE_NORMAL:
-							SB(_me[t].m7, 0, 4, GB(_m[t].m3, 0, 4)); // road works
+							SB(_m[t].m7, 0, 4, GB(_m[t].m3, 0, 4)); // road works
 							SB(_m[t].m6, 3, 3, GB(_m[t].m3, 4, 3));  // ground
 							SB(_m[t].m3, 0, 4, GB(_m[t].m4, 4, 4));  // tram bits
 							SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4));  // tram owner
@@ -900,7 +900,7 @@
 							break;
 
 						case ROAD_TILE_CROSSING:
-							SB(_me[t].m7, 0, 5, GB(_m[t].m4, 0, 5)); // road owner
+							SB(_m[t].m7, 0, 5, GB(_m[t].m4, 0, 5)); // road owner
 							SB(_m[t].m6, 3, 3, GB(_m[t].m3, 4, 3));  // ground
 							SB(_m[t].m3, 4, 4, GB(_m[t].m5, 0, 4));  // tram owner
 							SB(_m[t].m5, 0, 1, GB(_m[t].m4, 6, 1));  // road axis
@@ -921,7 +921,7 @@
 					if (!IsRoadStop(t)) break;
 
 					if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_m[t].m3, 0, 3));
-					SB(_me[t].m7, 0, 5, HasBit(_m[t].m6, 2) ? OWNER_TOWN : GetTileOwner(t));
+					SB(_m[t].m7, 0, 5, HasBit(_m[t].m6, 2) ? OWNER_TOWN : GetTileOwner(t));
 					SB(_m[t].m3, 4, 4, _m[t].m1);
 					_m[t].m4 = 0;
 					break;
@@ -932,11 +932,11 @@
 						if (fix_roadtypes) SetRoadTypes(t, (RoadTypes)GB(_m[t].m3, 0, 3));
 
 						Owner o = GetTileOwner(t);
-						SB(_me[t].m7, 0, 5, o); // road owner
+						SB(_m[t].m7, 0, 5, o); // road owner
 						SB(_m[t].m3, 4, 4, o == OWNER_NONE ? OWNER_TOWN : o); // tram owner
 					}
 					SB(_m[t].m6, 2, 4, GB(_m[t].m2, 4, 4)); // bridge type
-					SB(_me[t].m7, 5, 1, GB(_m[t].m4, 7, 1)); // snow/desert
+					SB(_m[t].m7, 5, 1, GB(_m[t].m4, 7, 1)); // snow/desert
 
 					_m[t].m2 = 0;
 					_m[t].m4 = 0;
@@ -1234,7 +1234,7 @@
 				} else {
 					/* The "lift has destination" bit has been moved from
 					 * m5[7] to m7[0]. */
-					SB(_me[t].m7, 0, 1, HasBit(_m[t].m5, 7));
+					SB(_m[t].m7, 0, 1, HasBit(_m[t].m5, 7));
 					ClrBit(_m[t].m5, 7);
 
 					/* The "lift is moving" bit has been removed, as it does
Index: src/saveload/map_sl.cpp
===================================================================
--- src/saveload/map_sl.cpp	(revision 19703)
+++ src/saveload/map_sl.cpp	(working copy)
@@ -226,7 +226,7 @@
 
 	for (TileIndex i = 0; i != size;) {
 		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);
-		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) _me[i++].m7 = buf[j];
+		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) _m[i++].m7 = buf[j];
 	}
 }
 
@@ -237,7 +237,7 @@
 
 	SlSetLength(size);
 	for (TileIndex i = 0; i != size;) {
-		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) buf[j] = _me[i++].m7;
+		for (uint j = 0; j != MAP_SL_BUF_SIZE; j++) buf[j] = _m[i++].m7;
 		SlArray(buf, MAP_SL_BUF_SIZE, SLE_UINT8);
 	}
 }
Index: src/station_map.h
===================================================================
--- src/station_map.h	(revision 19703)
+++ src/station_map.h	(working copy)
@@ -95,7 +95,7 @@
 static inline uint8 GetStationAnimationFrame(TileIndex t)
 {
 	assert(IsTileType(t, MP_STATION));
-	return _me[t].m7;
+	return _m[t].m7;
 }
 
 /**
@@ -107,7 +107,7 @@
 static inline void SetStationAnimationFrame(TileIndex t, uint8 frame)
 {
 	assert(IsTileType(t, MP_STATION));
-	_me[t].m7 = frame;
+	_m[t].m7 = frame;
 }
 
 /**
@@ -565,7 +565,7 @@
 	_m[t].m5 = section;
 	SB(_m[t].m6, 2, 1, 0);
 	SB(_m[t].m6, 3, 3, st);
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 /**
Index: src/tunnel_map.h
===================================================================
--- src/tunnel_map.h	(revision 19703)
+++ src/tunnel_map.h	(working copy)
@@ -57,7 +57,7 @@
 	_m[t].m4 = 0;
 	_m[t].m5 = TRANSPORT_ROAD << 2 | d;
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 	SetRoadOwner(t, ROADTYPE_ROAD, o);
 	if (o != OWNER_TOWN) SetRoadOwner(t, ROADTYPE_TRAM, o);
 	SetRoadTypes(t, r);
@@ -79,7 +79,7 @@
 	_m[t].m4 = 0;
 	_m[t].m5 = TRANSPORT_RAIL << 2 | d;
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 #endif /* TUNNEL_MAP_H */
Index: src/tunnelbridge_map.h
===================================================================
--- src/tunnelbridge_map.h	(revision 19703)
+++ src/tunnelbridge_map.h	(working copy)
@@ -54,7 +54,7 @@
 static inline bool HasTunnelBridgeSnowOrDesert(TileIndex t)
 {
 	assert(IsTileType(t, MP_TUNNELBRIDGE));
-	return HasBit(_me[t].m7, 5);
+	return HasBit(_m[t].m7, 5);
 }
 
 /**
@@ -68,7 +68,7 @@
 static inline void SetTunnelBridgeSnowOrDesert(TileIndex t, bool snow_or_desert)
 {
 	assert(IsTileType(t, MP_TUNNELBRIDGE));
-	SB(_me[t].m7, 5, 1, snow_or_desert);
+	SB(_m[t].m7, 5, 1, snow_or_desert);
 }
 
 /**
Index: src/bridge_map.h
===================================================================
--- src/bridge_map.h	(revision 19703)
+++ src/bridge_map.h	(working copy)
@@ -170,7 +170,7 @@
 	_m[t].m4 = 0;
 	_m[t].m5 = 1 << 7 | tt << 2 | d;
 	SB(_m[t].m6, 2, 4, bridgetype);
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 /**
Index: src/rail_map.h
===================================================================
--- src/rail_map.h	(revision 19703)
+++ src/rail_map.h	(working copy)
@@ -547,7 +547,7 @@
 	_m[t].m4 = 0;
 	_m[t].m5 = RAIL_TILE_NORMAL << 6 | b;
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 
@@ -560,7 +560,7 @@
 	_m[t].m4 = 0;
 	_m[t].m5 = RAIL_TILE_DEPOT << 6 | d;
 	SB(_m[t].m6, 2, 4, 0);
-	_me[t].m7 = 0;
+	_m[t].m7 = 0;
 }
 
 #endif /* RAIL_MAP_H */