extern "C" {

#endif

#if defined(_MSC_VER) && _MSC_VER >= 1400 // MSVC 2005 safety checks

# pragma warning(disable: 4996)   // '_wfopen' was declared deprecated

# define _CRT_SECURE_NO_DEPRECATE // all deprecated 'unsafe string functions

	 * @return Returns true if the aircraft is a helicopter/airplane and

	 * false if it is a shadow or a rotor

	 */

	{

		/* To be fully correct the commented out functionality is the proper one,

		 * but since value can only be 0 or 2, it is sufficient to only check <= 2

	 * @param tile The tile to get the base station from.

	 * @return the station associated with that tile.

	 */

	{

		return BaseStation::Get(GetStationIndex(tile));

	}

	 * facilities left.

	 * @return true if still in use

	 */

	{

		return (this->facilities & ~FACIL_WAYPOINT) != 0;

	}

	 * Set station type correctly

	 * @param tile The base tile of the station.

	 */

			BaseStation(tile)

	{

		this->facilities = EXPECTED_FACIL;

	 * @param st the station to check.

	 * @return true if the station is the type we expect it to be.

	 */

	{

		return (st->facilities & FACIL_WAYPOINT) == EXPECTED_FACIL;

	}

	 * @param index tested index

	 * @return is this index valid index of T?

	 */

	{

		return BaseStation::IsValidID(index) && IsExpected(BaseStation::Get(index));

	}

	 * Gets station with given index

	 * @return pointer to station with given index casted to T *

	 */

	{

		return (T *)BaseStation::Get(index);

	}

	 * Returns station if the index is a valid index for this station type

	 * @return pointer to station with given index if it's a station of this type

	 */

	{

		return IsValidID(index) ? Get(index) : NULL;

	}

	 * @param tile The tile to get the station from.

	 * @return the station associated with that tile.

	 */

	{

		return GetIfValid(GetStationIndex(tile));

	}

	 * @param st BaseStation pointer

	 * @return pointer to SpecializedStation

	 */

	{

		assert(IsExpected(st));

		return (T *)st;

	 * @param st BaseStation pointer

	 * @return pointer to SpecializedStation

	 */

	{

		assert(IsExpected(st));

		return (const T *)st;

public:

	/** Default constructor. */

	{

		this->Clear();

	}

	/** Reset all entries. */

	{

		memset(this->amount, 0, sizeof(this->amount));

	}

	 * Read/write access to an amount of a specific cargo type.

	 * @param cargo Cargo type to access.

	 */

	{

		return this->amount[cargo];

	}

	 * Read-only access to an amount of a specific cargo type.

	 * @param cargo Cargo type to access.

	 */

	{

		return this->amount[cargo];

	}

 * @param new_size Size of the remaining part.

 * @return Split off part, or NULL if no packet could be allocated!

 */

{

	if (!CargoPacket::CanAllocateItem()) return NULL;

 * Merge another packet into this one.

 * @param cp Packet to be merged in.

 */

{

	this->count += cp->count;

	this->feeder_share += cp->feeder_share;

	 * Gets the number of 'items' in this packet.

	 * @return Item count.

	 */

	{

		return this->count;

	}

	 * the feeder chain.

	 * @return Feeder share.

	 */

	{

		return this->feeder_share;

	}

	 * it is capped at 255.

	 * @return Length this cargo has been in transit.

	 */

	{

		return this->days_in_transit;

	}

	 * Gets the type of the cargo's source. industry, town or head quarter.

	 * @return Source type.

	 */

	{

		return this->source_type;

	}

	 * Gets the ID of the cargo's source. An IndustryID, TownID or CompanyID.

	 * @return Source ID.

	 */

	{

		return this->source_id;

	}

	 * Gets the ID of the station where the cargo was loaded for the first time.

	 * @return StationID.

	 */

	{

		return this->source;

	}

	 * Gets the coordinates of the cargo's source station.

	 * @return Source station's coordinates.

	 */

	{

		return this->source_xy;

	}

	 * Gets the coordinates of the cargo's last loading station.

	 * @return Last loading station's coordinates.

	 */

	{

		return this->loaded_at_xy;

	}

	 * Returns a pointer to the cargo packet list (so you can iterate over it etc).

	 * @return Pointer to the packet list.

	 */

	{

		return &this->packets;

	}

	 * Checks whether this list is empty.

	 * @return True if and only if the list is empty.

	 */

	{

		return this->count == 0;

	}

	 * Returns the number of cargo entities in this list.

	 * @return The before mentioned number.

	 */

	{

		return this->count;

	}

	 * Returns source of the first cargo packet in this list.

	 * @return The before mentioned source.

	 */

	{

		return this->Empty() ? INVALID_STATION : this->packets.front()->source;

	}

	 * Returns average number of days in transit for a cargo entity.

	 * @return The before mentioned number.

	 */

	{

		return this->count == 0 ? 0 : this->cargo_days_in_transit / this->count;

	}

	 * Returns total sum of the feeder share for all packets.

	 * @return The before mentioned number.

	 */

	{

		return this->feeder_share;

	}

	 * Determines index of this cargospec

	 * @return index (in the CargoSpec::array array)

	 */

	{

		return this - CargoSpec::array;

	}

	 * @return is this cargospec valid?

	 * @note assert(cs->IsValid()) can be triggered when GRF config is modified

	 */

	{

		return this->bitnum != INVALID_CARGO;

	}

	 * Total number of cargospecs, both valid and invalid

	 * @return length of CargoSpec::array

	 */

	{

		return lengthof(CargoSpec::array);

	}

	 * @param index ID of cargo

	 * @pre index is a valid cargo ID

	 */

	{

		assert(index < lengthof(CargoSpec::array));

		return &CargoSpec::array[index];

	 * Adds the given cost to the cost of the command.

	 * @param cost the cost to add

	 */

	{

		this->cost += cost;

	}

	 * Multiplies the cost of the command by the given factor.

	 * @param factor factor to multiply the costs with

	 */

	{

		this->cost *= factor;

	}

	 * The costs as made up to this moment

	 * @return the costs

	 */

	{

		return this->cost;

	}

	 * The expense type of the cost

	 * @return the expense type

	 */

	{

		return this->expense_type;

	}

	 * Did this command succeed?

	 * @return true if and only if it succeeded

	 */

	{

		return this->success;

	}

	 * Did this command fail?

	 * @return true if and only if it failed

	 */

	{

		return !this->success;

	}

	 * @param index Index in the pool.

	 * @return \c true if it is a valid, computer controlled company, else \c false.

	 */

	{

		const Company *c = Company::GetIfValid(index);

		return c != NULL && c->is_ai;

	 * @return \c true if it is a valid, human controlled company, else \c false.

	 * @note If you know that \a index refers to a valid company, you can use #IsHumanID() instead.

	 */

	{

		const Company *c = Company::GetIfValid(index);

		return c != NULL && !c->is_ai;

	 * @pre \a index must be a valid CompanyID.

	 * @note If you don't know whether \a index refers to a valid company, you should use #IsValidHumanID() instead.

	 */

	{

		return !Company::Get(index)->is_ai;

	}

 * @return NULL when num_elements == 0, non-NULL otherwise.

 */

template <typename T>

{

	/*

	 * MorphOS cannot handle 0 elements allocations, or rather that always

 * @return NULL when num_elements == 0, non-NULL otherwise.

 */

template <typename T>

{

	/*

	 * MorphOS cannot handle 0 elements allocations, or rather that always

 * @return NULL when num_elements == 0, non-NULL otherwise.

 */

template <typename T>

{

	/*

	 * MorphOS cannot handle 0 elements allocations, or rather that always

	 * Gets a pointer to the data stored in this wrapper.

	 * @return the pointer.

	 */

	{

		return data;

	}

	 * Gets a pointer to the data stored in this wrapper.

	 * @return the pointer.

	 */

	{

		return data;

	}

	 * @note needed because endof does not work properly for pointers.

	 * @return the 'endof' pointer.

	 */

	{

#if !defined(__NDS__)

		return endof(data);

	 * Get the currently allocated buffer.

	 * @return the buffer

	 */

	{

		return this->buffer;

	}

	 * @param size the amount of bytes to allocate.

	 * @return the given amounts of bytes zeroed.

	 */

	/**

	 * Memory allocator for an array of class instances.

	 * @param size the amount of bytes to allocate.

	 * @return the given amounts of bytes zeroed.

	 */

	/**

	 * Memory release for a single class instance.

	 * @param ptr  the memory to free.

	 */

	/**

	 * Memory release for an array of class instances.

	 * @param ptr  the memory to free.

	 */

};

#endif /* ALLOC_TYPE_HPP */

 * @return The selected bits, aligned to a LSB.

 */

template <typename T>

{

	return (x >> s) & (((T)1U << n) - 1);

}

 * @return The new value of \a x

 */

template <typename T, typename U>

{

	x &= (T)(~((((T)1U << n) - 1) << s));

	x |= (T)(d << s);

 * @return The new value of x

 */

template <typename T, typename U>

{

	const T mask = ((((T)1U << n) - 1) << s);

	x = (T)((x & ~mask) | ((x + (i << s)) & mask));

 * @return True if the bit is set, false else.

 */

template <typename T>

{

	return (x & ((T)1U << y)) != 0;

}

 * @return The new value of the old value with the bit set

 */

template <typename T>

{

	return x = (T)(x | ((T)1U << y));

}

 * @return The new value of the old value with the bit cleared

 */

template <typename T>

{

	return x = (T)(x & ~((T)1U << y));

}

 * @return The new value of the old value with the bit toggled

 */

template <typename T>

{

	return x = (T)(x ^ ((T)1U << y));

}

 * @return The position of the first bit which is set

 * @see FIND_FIRST_BIT

 */

{

	if ((value & 0xFF) == 0) {

		return FIND_FIRST_BIT((value >> 8) & 0x3F) + 8;

 * @return The new value with the first bit cleared

 */

template <typename T>

{

	return value &= (T)(value - 1);

}

 * @return does \a value have exactly 1 bit set?

 */

template <typename T>

{

	return value != 0 && (value & (value - 1)) == 0;

}

 * @return does \a value have at most 1 bit set?

 */

template <typename T>

{

	return (value & (value - 1)) == 0;

}

 * @return A bit rotated number

 */

template <typename T>

{

	return (T)(x << n | x >> (sizeof(x) * 8 - n));

}

 * @return A bit rotated number

 */

template <typename T>

{

	return (T)(x >> n | x << (sizeof(x) * 8 - n));

}

	 * @param x the variable to bitswap

	 * @return the bitswapped value.

	 */

	{

#if !defined(__ICC) && defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4)  && __GNUC_MINOR__ >= 3))

		/* GCC >= 4.3 provides a builtin, resulting in faster code */

	 * @param x the variable to bitswap

	 * @return the bitswapped value.

	 */

	{

		return (x >> 8) | (x << 8);

	}

	#define TO_LE32X(x)  (x)

#endif /* TTD_ENDIAN == TTD_BIG_ENDIAN */

{

	return FROM_LE16(*(const uint16*)x);

}

{

#if OTTD_ALIGNMENT == 1

	return ((const byte*)x)[0] | ((const byte*)x)[1] << 8;

/** Some enums need to have allowed incrementing (i.e. StationClassID) */

#define DECLARE_POSTFIX_INCREMENT(type) \

	{ \

		type e_org = e; \

		e = (type)((int)e + 1); \

		return e_org; \

	} \

	{ \

		type e_org = e; \

		e = (type)((int)e - 1); \

/** Operators to allow to work with enum as with type safe bit set in C++ */

# define DECLARE_ENUM_AS_BIT_SET(mask_t) \

/**

	storage_type m_val;  ///< here we hold the actual value in small (i.e. byte) form

	/** Cast operator - invoked then the value is assigned to the Tenum_t type */

	{

		return (enum_type)m_val;

	}

	/** Assignment operator (from Tenum_t type) */

	{

		m_val = (storage_type)e;

		return *this;

	}

	/** Assignment operator (from Tenum_t type) */

	{

		m_val = (storage_type)u;

		return *this;

	}

	/** postfix ++ operator on tiny type */

	{

		TinyEnumT org = *this;