{

	static_assert(lengthof(cargoes) <= lengthof(suffixes));

	if (indspec->behaviour & INDUSTRYBEH_CARGOTYPES_UNLIMITED) {

		/* Reworked behaviour with new many-in-many-out scheme */

		for (uint j = 0; j < lengthof(suffixes); j++) {

				byte local_id = indspec->grf_prop.grffile->cargo_map[cargoes[j]]; // should we check the value for valid?

				uint cargotype = local_id << 16 | use_input;

				GetCargoSuffix(cargotype, cst, ind, ind_type, indspec, suffixes[j]);

			} else {

				suffixes[j].text[0] = '\0';

				suffixes[j].display = CSD_CARGO;

		for (uint j = 0; j < lengthof(suffixes); j++) {

			suffixes[j].text[0] = '\0';

			suffixes[j].display = CSD_CARGO;

		}

		switch (use_input) {

			case CARGOSUFFIX_OUT:

				break;

			case CARGOSUFFIX_IN:

				break;

			default:

				NOT_REACHED();

		}

	}

}

	{

		std::string cargostring;

		int numcargo = 0;

		int firstcargo = -1;

		for (int j = 0; j < cargolistlen; j++) {

			numcargo++;

			if (firstcargo < 0) {

				firstcargo = j;

				continue;

			}

			SetDParam(0, CargoSpec::Get(cargolist[j])->name);

		CargoSuffix cargo_suffix[lengthof(i->accepts_cargo)];

		GetAllCargoSuffixes(CARGOSUFFIX_IN, CST_VIEW, i, i->type, ind, i->accepts_cargo, cargo_suffix);

		bool stockpiling = HasBit(ind->callback_mask, CBM_IND_PRODUCTION_CARGO_ARRIVAL) || HasBit(ind->callback_mask, CBM_IND_PRODUCTION_256_TICKS);

		for (byte j = 0; j < lengthof(i->accepts_cargo); j++) {

			has_accept = true;

			if (first) {

				DrawString(ir, STR_INDUSTRY_VIEW_REQUIRES);

				ir.top += FONT_HEIGHT_NORMAL;

				first = false;

			}

		GetAllCargoSuffixes(CARGOSUFFIX_OUT, CST_VIEW, i, i->type, ind, i->produced_cargo, cargo_suffix);

		int line_height = this->editable == EA_RATE ? this->cheat_line_height : FONT_HEIGHT_NORMAL;

		int text_y_offset = (line_height - FONT_HEIGHT_NORMAL) / 2;

		int button_y_offset = (line_height - SETTING_BUTTON_HEIGHT) / 2;

		first = true;

		for (byte j = 0; j < lengthof(i->produced_cargo); j++) {

			if (first) {

				if (has_accept) ir.top += WidgetDimensions::scaled.vsep_wide;

				DrawString(ir, STR_INDUSTRY_VIEW_PRODUCTION_LAST_MONTH_TITLE);

				ir.top += FONT_HEIGHT_NORMAL;

				if (this->editable == EA_RATE) this->production_offset_y = ir.top;

				first = false;

						break;

					case EA_RATE:

						if (pt.y >= this->production_offset_y) {

							int row = (pt.y - this->production_offset_y) / this->cheat_line_height;

							for (uint j = 0; j < lengthof(i->produced_cargo); j++) {

								row--;

								if (row < 0) {

									line = (InfoLine)(IL_RATE1 + j);

									break;

								}

							}

static void UpdateIndustryProduction(Industry *i)

{

	const IndustrySpec *indspec = GetIndustrySpec(i->type);

	if (indspec->UsesOriginalEconomy()) i->RecomputeProductionMultipliers();

	for (byte j = 0; j < lengthof(i->produced_cargo); j++) {

			i->last_month_production[j] = 8 * i->production_rate[j];

		}

	}

}

/** Widget definition of the view industry gui */

		case CF_ANY:

			accepted_cargo_matches = true;

			break;

		case CF_NONE:

			accepted_cargo_matches = std::all_of(std::begin((*industry)->accepts_cargo), std::end((*industry)->accepts_cargo), [](CargoID cargo) {

			});

			break;

		default:

			const auto &ac = (*industry)->accepts_cargo;

			accepted_cargo_matches = std::find(std::begin(ac), std::end(ac), accepted_cargo) != std::end(ac);

		case CF_ANY:

			produced_cargo_matches = true;

			break;

		case CF_NONE:

			produced_cargo_matches = std::all_of(std::begin((*industry)->produced_cargo), std::end((*industry)->produced_cargo), [](CargoID cargo) {

			});

			break;

		default:

			const auto &pc = (*industry)->produced_cargo;

			produced_cargo_matches = std::find(std::begin(pc), std::end(pc), produced_cargo) != std::end(pc);

	 * @return percents of cargo transported, or -1 if industry doesn't use this cargo slot

	 */

	static inline int GetCargoTransportedPercentsIfValid(const Industry *i, uint id)

	{

		assert(id < lengthof(i->produced_cargo));

		return ToPercent8(i->last_month_pct_transported[id]);

	}

	/**

	 * Returns value representing industry's transported cargo

	 *  percentage for industry sorting

		CargoID filter = IndustryDirectoryWindow::produced_cargo_filter;

		if (filter == CF_NONE) return IndustryTypeSorter(a, b);

		uint prod_a = 0, prod_b = 0;

		for (uint i = 0; i < lengthof(a->produced_cargo); i++) {

			if (filter == CF_ANY) {

			} else {

				if (a->produced_cargo[i] == filter) prod_a += a->last_month_production[i];

				if (b->produced_cargo[i] == filter) prod_b += b->last_month_production[i];

			}

		}

		int r = prod_a - prod_b;

			const char *suffix;

			uint transported;

		};

		std::vector<CargoInfo> cargos;

		for (byte j = 0; j < lengthof(i->produced_cargo); j++) {

			cargos.push_back({ i->produced_cargo[j], i->last_month_production[j], cargo_suffix[j].text.c_str(), ToPercent8(i->last_month_pct_transported[j]) });

		}

		switch (static_cast<IndustryDirectoryWindow::SorterType>(this->industries.SortType())) {

			case IndustryDirectoryWindow::SorterType::ByName:

			case IndustryDirectoryWindow::SorterType::ByType:

	 * @param producer Cargo is produced (if \c false, cargo is assumed to be accepted).

	 * @return Horizontal connection index, or \c -1 if not accepted at all.

	 */

	int ConnectCargo(CargoID cargo, bool producer)

	{

		assert(this->type == CFT_CARGO);

		/* Find the vertical cargo column carrying the cargo. */

		int column = -1;

		for (int i = 0; i < this->u.cargo.num_cargoes; i++) {

			if (cargo == this->u.cargo.vertical_cargoes[i]) {

				column = i;

				break;

			}

		}

		if (column < 0) return -1;

		if (producer) {

			this->u.cargo.supp_cargoes[column]  = column;

		} else {

			this->u.cargo.cust_cargoes[column] = column;

		}

		return column;

	}

	/**

	 */

	bool HasConnection()

	{

		assert(this->type == CFT_CARGO);

		for (uint i = 0; i < MAX_CARGOES; i++) {

		}

		return false;

	}

	/**

	 * Make a piece of cargo column.

	void MakeCargo(const CargoID *cargoes, uint length, int count = -1, bool top_end = false, bool bottom_end = false)

	{

		this->type = CFT_CARGO;

		uint i;

		uint num = 0;

		for (i = 0; i < MAX_CARGOES && i < length; i++) {

				this->u.cargo.vertical_cargoes[num] = cargoes[i];

				num++;

			}

		}

		this->u.cargo.num_cargoes = (count < 0) ? num : count;

		for (; num < MAX_CARGOES; num++) this->u.cargo.vertical_cargoes[num] = INVALID_CARGO;

				} else {

					other_right = this->u.industry.other_produced;

					other_left  = this->u.industry.other_accepted;

				}

				ypos1 += CargoesField::cargo_border.height + (FONT_HEIGHT_NORMAL - CargoesField::cargo_line.height) / 2;

				for (uint i = 0; i < CargoesField::max_cargoes; i++) {

						const CargoSpec *csp = CargoSpec::Get(other_right[i]);

						int xp = xpos + industry_width + CargoesField::cargo_stub.width;

						DrawHorConnection(xpos + industry_width, xp - 1, ypos1, csp);

						GfxDrawLine(xp, ypos1, xp, ypos1 + CargoesField::cargo_line.height - 1, CARGO_LINE_COLOUR);

					}

						const CargoSpec *csp = CargoSpec::Get(other_left[i]);

						int xp = xpos - CargoesField::cargo_stub.width;

						DrawHorConnection(xp + 1, xpos - 1, ypos1, csp);

						GfxDrawLine(xp, ypos1, xp, ypos1 + CargoesField::cargo_line.height - 1, CARGO_LINE_COLOUR);

					}

					ypos1 += FONT_HEIGHT_NORMAL + CargoesField::cargo_space.height;

				} else {

					hor_left  = this->u.cargo.supp_cargoes;

					hor_right = this->u.cargo.cust_cargoes;

				}

				ypos += CargoesField::cargo_border.height + vert_inter_industry_space / 2 + (FONT_HEIGHT_NORMAL - CargoesField::cargo_line.height) / 2;

				for (uint i = 0; i < MAX_CARGOES; i++) {

						int col = hor_left[i];

						int dx = 0;

						const CargoSpec *csp = CargoSpec::Get(this->u.cargo.vertical_cargoes[col]);

						for (; col > 0; col--) {

							int lf = cargo_base + col * CargoesField::cargo_line.width + (col - 1) * CargoesField::cargo_space.width;

							DrawHorConnection(lf, lf + CargoesField::cargo_space.width - dx, ypos, csp);

							dx = 1;

						}

						DrawHorConnection(xpos, cargo_base - dx, ypos, csp);

					}

						int col = hor_right[i];

						int dx = 0;

						const CargoSpec *csp = CargoSpec::Get(this->u.cargo.vertical_cargoes[col]);

						for (; col < this->u.cargo.num_cargoes - 1; col++) {

							int lf = cargo_base + (col + 1) * CargoesField::cargo_line.width + col * CargoesField::cargo_space.width;

							DrawHorConnection(lf + dx - 1, lf + CargoesField::cargo_space.width - 1, ypos, csp);

				break;

			}

			case CFT_CARGO_LABEL:

				ypos += CargoesField::cargo_border.height + vert_inter_industry_space / 2;

				for (uint i = 0; i < MAX_CARGOES; i++) {

						const CargoSpec *csp = CargoSpec::Get(this->u.cargo_label.cargoes[i]);

						DrawString(xpos + WidgetDimensions::scaled.framerect.left, xpos + industry_width - 1 - WidgetDimensions::scaled.framerect.right, ypos, csp->name, TC_WHITE,

								(this->u.cargo_label.left_align) ? SA_LEFT : SA_RIGHT);

					}

					ypos += FONT_HEIGHT_NORMAL + CargoesField::cargo_space.height;

				}

			vpos += FONT_HEIGHT_NORMAL + CargoesField::cargo_space.width;

		}

		if (row == MAX_CARGOES) return INVALID_CARGO;

		/* row = 0 -> at first horizontal row, row = 1 -> second horizontal row, 2 = 3rd horizontal row. */

		if (col == 0) {

			if (left != nullptr) {

				if (left->type == CFT_INDUSTRY) return left->u.industry.other_produced[row];

				if (left->type == CFT_CARGO_LABEL && !left->u.cargo_label.left_align) return left->u.cargo_label.cargoes[row];

			}

			return INVALID_CARGO;

		}

		if (col == this->u.cargo.num_cargoes) {

			if (right != nullptr) {

				if (right->type == CFT_INDUSTRY) return right->u.industry.other_accepted[row];

				if (right->type == CFT_CARGO_LABEL && right->u.cargo_label.left_align) return right->u.cargo_label.cargoes[row];

			}

			return INVALID_CARGO;

		}

		if (row >= col) {

			/* Clicked somewhere in-between vertical cargo connection.

			 * Since the horizontal connection is made in the same order as the vertical list, the above condition

			 * ensures we are left-below the main diagonal, thus at the supplying side.

			 */

		} else {

			/* Clicked at a customer connection. */

		}

	}

	/**

	 * Decide what cargo the user clicked in the cargo label field.

	 * @param pt Click position in the cargo label field.

				int col = cargo_fld->ConnectCargo(indsp->produced_cargo[i], true);

				if (col < 0) others[other_count++] = indsp->produced_cargo[i];

			}

			/* Allocate other cargoes in the empty holes of the horizontal cargo connections. */

			for (uint i = 0; i < CargoesField::max_cargoes && other_count > 0; i++) {

			}

		} else {

			/* Houses only display what is demanded. */

			for (uint i = 0; i < cargo_fld->u.cargo.num_cargoes; i++) {

				CargoID cid = cargo_fld->u.cargo.vertical_cargoes[i];

				if (cid == CT_PASSENGERS || cid == CT_MAIL) cargo_fld->ConnectCargo(cid, true);

				int col = cargo_fld->ConnectCargo(indsp->accepts_cargo[i], false);

				if (col < 0) others[other_count++] = indsp->accepts_cargo[i];

			}

			/* Allocate other cargoes in the empty holes of the horizontal cargo connections. */

			for (uint i = 0; i < CargoesField::max_cargoes && other_count > 0; i++) {

			}

		} else {

			/* Houses only display what is demanded. */

			for (uint i = 0; i < cargo_fld->u.cargo.num_cargoes; i++) {

				for (uint h = 0; h < NUM_HOUSES; h++) {

					HouseSpec *hs = HouseSpec::Get(h);

	 * @param length2  Number of cargoes in the second cargo array.

	 * @return Arrays have at least one valid cargo in common.

	 */

	static bool HasCommonValidCargo(const CargoID *cargoes1, uint length1, const CargoID *cargoes2, uint length2)

	{

		while (length1 > 0) {

				for (uint i = 0; i < length2; i++) if (*cargoes1 == cargoes2[i]) return true;

			}

			cargoes1++;

			length1--;

		}

		return false;

	 * @param length  Number of cargoes in the array.

	 * @return Houses can supply at least one of the cargoes.

	 */

	static bool HousesCanSupply(const CargoID *cargoes, uint length)

	{

		for (uint i = 0; i < length; i++) {

			if (cargoes[i] == CT_PASSENGERS || cargoes[i] == CT_MAIL) return true;

		}

		return false;

	}

	/**

			case LT_ARCTIC:    climate_mask = HZ_SUBARTC_ABOVE | HZ_SUBARTC_BELOW; break;

			case LT_TROPIC:    climate_mask = HZ_SUBTROPIC; break;

			case LT_TOYLAND:   climate_mask = HZ_TOYLND; break;

			default: NOT_REACHED();

		}

		for (uint i = 0; i < length; i++) {

			for (uint h = 0; h < NUM_HOUSES; h++) {

				HouseSpec *hs = HouseSpec::Get(h);

				if (!hs->enabled || !(hs->building_availability & climate_mask)) continue;

				for (uint j = 0; j < lengthof(hs->accepts_cargo); j++) {

						break;

					case CFT_CARGO: {

						CargoesField *lft = (fieldxy.x > 0) ? this->fields[fieldxy.y].columns + fieldxy.x - 1 : nullptr;

						CargoesField *rgt = (fieldxy.x < 4) ? this->fields[fieldxy.y].columns + fieldxy.x + 1 : nullptr;

						CargoID cid = fld->CargoClickedAt(lft, rgt, xy);

						break;

					}

					case CFT_CARGO_LABEL: {

						CargoID cid = fld->CargoLabelClickedAt(xy);

						break;

					}

					default:

						break;

				}

				}

				return true;

			default:

				break;

		}

			const CargoSpec *csp = CargoSpec::Get(cid);

			uint64 params[5];

			params[0] = csp->name;

			GuiShowTooltips(this, STR_INDUSTRY_CARGOES_CARGO_TOOLTIP, 1, params, close_cond);

			return true;

		}