int32 supply = scaler.EffectiveSupply(job[from_id], job[to_id]);

			assert(supply > 0);

			/* Scale the distance by mod_dist around max_distance */

			int32 distance = this->max_distance - (this->max_distance -

			/* Scale the accuracy by distance around accuracy / 2 */

			int32 divisor = this->accuracy * (this->mod_dist - 50) / 100 +

					this->accuracy * distance / this->max_distance + 1;

			assert(divisor > 0);

/* Initialize the link-graph-pool */

LinkGraphPool _link_graph_pool("LinkGraph");

INSTANTIATE_POOL_METHODS(LinkGraph)

/**

 * Create a node or clear it.

 * @param st ID of the associated station.

 * @param demand Demand for cargo at the station.

 */

{

	this->supply = 0;

	this->demand = demand;

	this->station = st;

	this->last_update = INVALID_DATE;

}

/**

 * Create an edge.

 */

{

	this->capacity = 0;

	this->usage = 0;

	this->last_unrestricted_update = INVALID_DATE;

	this->last_restricted_update = INVALID_DATE;

	this->next_edge = INVALID_NODE;

}

	/* Not doing EraseRow here, as having the extra invalid row doesn't hurt

	 * and removing it would trigger a lot of memmove. The data has already

	 * been copied around in the loop above. */

}

/**

 * Add a node to the component and create empty edges associated with it. Set

 * the station's last_component to this component. Calculate the distances to all

 * other nodes. The distances to _all_ nodes are important as the demand

 * calculator relies on their availability.

 * @param st New node's station.

 * @return New node's ID.

	this->nodes.Append();

	/* Avoid reducing the height of the matrix as that is expensive and we

	 * most likely will increase it again later which is again expensive. */

	this->edges.Resize(new_node + 1U,

			max(new_node + 1U, this->edges.Height()));

			HasBit(good.status, GoodsEntry::GES_ACCEPTANCE));

	BaseEdge *new_edges = this->edges[new_node];

	/* Reset the first edge starting at the new node */

	new_edges[new_node].next_edge = INVALID_NODE;

	for (NodeID i = 0; i <= new_node; ++i) {

	}

	return new_node;

}

/**

 * Fill an edge with values from a link. Set the restricted or unrestricted

	 * in a separate thread.

	 */

	struct BaseNode {

		uint supply;             ///< Supply at the station.

		uint demand;             ///< Acceptance at the station.

		StationID station;       ///< Station ID.

		Date last_update;        ///< When the supply was last updated.

	};

	/**

	 * An edge in the link graph. Corresponds to a link between two stations or at

	 * least the distance between them. Edges from one node to itself contain the

	 * ID of the opposite Node of the first active edge (i.e. not just distance) in

	 * the column as next_edge.

	 */

	struct BaseEdge {

		uint capacity;                 ///< Capacity of the link.

		uint usage;                    ///< Usage of the link.

		Date last_unrestricted_update; ///< When the unrestricted part of the link was last updated.

		Date last_restricted_update;   ///< When the restricted part of the link was last updated.

		NodeID next_edge;              ///< Destination of next valid edge starting at the same source node.

	};

	/**

	 * Wrapper for an edge (const or not) allowing retrieval, but no modification.

	 * @tparam Tedge Actual edge class, may be "const BaseEdge" or just "BaseEdge".

	 */

		 * Get edge's usage.

		 * @return Usage.

		 */

		uint Usage() const { return this->edge.usage; }

		/**

		 * Get the date of the last update to the edge's unrestricted capacity.

		 * @return Last update.

		 */

		Date LastUnrestrictedUpdate() const { return this->edge.last_unrestricted_update; }

		/**

		/**

		 * Get node's last update.

		 * @return Last update.

		 */

		Date LastUpdate() const { return this->node.last_update; }

	};

	/**

	 * Base class for iterating across outgoing edges of a node. Only the real

	 * edges (those with capacity) are iterated. The ones with only distance

	 * information are skipped.

		{

			this->node.supply += supply;

			this->node.last_update = _date;

		}

		/**

		 * Set the node's demand.

		 * @param demand New demand for the node.

		 */

		void SetDemand(uint demand)

		{

			this->node.demand = demand;

	{

		return base * 30 / (_date - this->last_compression + 1);

	}

	NodeID AddNode(const Station *st);

	void RemoveNode(NodeID id);

protected:

	friend class LinkGraph::ConstNode;

	friend class LinkGraph::Node;

	friend const SaveLoad *GetLinkGraphDesc();

	friend const SaveLoad *GetLinkGraphJobDesc();

		annos.erase(i);

		NodeID from = source->GetNode();

		iter.SetNode(source_node, from);

		for (NodeID to = iter.Next(); to != INVALID_NODE; to = iter.Next()) {

			if (to == from) continue; // Not a real edge but a consumption sign.

			Edge edge = this->job[from][to];

			uint capacity = edge.Capacity();

			if (this->max_saturation != UINT_MAX) {

				capacity *= this->max_saturation;

				capacity /= 100;

				if (capacity == 0) capacity = 1;

			}

			/* punish in-between stops a little */

			Tannotation *dest = static_cast<Tannotation *>(paths[to]);

			if (dest->IsBetter(source, capacity, capacity - edge.Flow(), distance)) {

				annos.erase(dest);

				dest->Fork(source, capacity, capacity - edge.Flow(), distance);

				annos.insert(dest);

			}

/* Edges and nodes are saved in the correct order, so we don't need to save their IDs. */

/**

 * SaveLoad desc for a link graph node.

 */

static const SaveLoad _node_desc[] = {

};

/**

 * SaveLoad desc for a link graph edge.

 */

static const SaveLoad _edge_desc[] = {

};

/**

 * Save/load a link graph.

 * @param comp Link graph to be saved or loaded.

 */

void SaveLoad_LinkGraph(LinkGraph &lg)

{

	uint size = lg.Size();

	for (NodeID from = 0; from < size; ++from) {

		Node *node = &lg.nodes[from];

		SlObject(node, _node_desc);

		}

	}

}

/**

 * Save a link graph job.

/**

 * Spawn the threads for running link graph calculations.

 * Has to be done after loading as the cargo classes might have changed.

 */

void AfterLoadLinkGraphs()

{

	LinkGraphSchedule::Instance()->SpawnAll();

}

/**

 * Save all link graphs.

 */

 *  185   25620

 *  186   25833

 *  187   25899

 *  188   26169   1.4.x

 *  189   26450

 *  190   26547

 */

SavegameType _savegame_type; ///< type of savegame we are loading

uint32 _ttdp_version;     ///< version of TTDP savegame (if applicable)

uint16 _sl_version;       ///< the major savegame version identifier

byte   _sl_minor_version; ///< the minor savegame version, DO NOT USE!

	if (!Station::IsExpected(st)) return;

	Station *full_station = Station::From(st);

	for (CargoID c = 0; c < NUM_CARGO; ++c) {

		LinkGraphID lg = full_station->goods[c].link_graph;

		if (!LinkGraph::IsValidID(lg)) continue;

	}

}

/**

 * Common part of building various station parts and possibly attaching them to an existing one.

 * @param [in,out] st Station to attach to