static const char *const kEoB2ChargenStrings1AmigaGerman[9] = {
	"Die Party ist\rkomplett. W""\xe4""hle\rSPIEL oder\rdr""\xfc""cke 'P', um\rzu starten.",
	"          ",
	"RK\rTP\rSTF",
	"%s\r%d\r%d\r%d\r%d\r%d",
	"%d\r%d",
	"%d",
	"%d/%d",
	"%d/%d/%d",
	"W""\xe4""hle die Box des\rCharakters, den du\rerschaffen oder\ransehen willst."
};

static const StringListProvider kEoB2ChargenStrings1AmigaGermanProvider = { ARRAYSIZE(kEoB2ChargenStrings1AmigaGerman), kEoB2ChargenStrings1AmigaGerman };

static const char *const kEoB2ChargenStrings2AmigaGerman[12] = {
	"%s",
	"%d",
	"%s",
	"%d",
	"%d",
	"%d",
	"%s",
	"%d",
	"W""\xc4""HLE RASSE:",
	"W""\xc4""HLE KLASSE:",
	"W""\xc4""HLE GESINNUNG:",
	"Name:"
};

static const StringListProvider kEoB2ChargenStrings2AmigaGermanProvider = { ARRAYSIZE(kEoB2ChargenStrings2AmigaGerman), kEoB2ChargenStrings2AmigaGerman };

static const char *const kEoB2ChargenStatStringsAmigaGerman[12] = {
	"ST""\xc4",
	"INT",
	"WEI",
	"GES",
	"KON",
	"CHA",
	"ST""\xc4""RKE",
	"INTELLIGENZ",
	"WEISHEIT",
	"GESCHICK",
	"KONSTITUTION",
	"CHARISMA"
};

static const StringListProvider kEoB2ChargenStatStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2ChargenStatStringsAmigaGerman), kEoB2ChargenStatStringsAmigaGerman };

static const char *const kEoB2ChargenRaceSexStringsAmigaGerman[12] = {
	"MENSCH, MANN",
	"MENSCH, FRAU",
	"ELF, MANN",
	"ELF, FRAU",
	"HALBELF, MANN",
	"HALBELF, FRAU",
	"ZWERG, MANN",
	"ZWERG, FRAU",
	"GNOM, MANN",
	"GNOM, FRAU",
	"HALBLING, MANN",
	"HALBLING, FRAU"
};

static const StringListProvider kEoB2ChargenRaceSexStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2ChargenRaceSexStringsAmigaGerman), kEoB2ChargenRaceSexStringsAmigaGerman };

static const char *const kEoB2ChargenClassStringsAmigaGerman[21] = {
	"K""\xc4""MPFER",
	"WALDL""\xc4""UFER",
	"PALADIN",
	"MAGIER",
	"KLERIKER",
	"DIEB",
	"K""\xc4""MPFER/KLERIKER",
	"K""\xc4""MPFER/DIEB",
	"K""\xc4""MPFER/MAGIER",
	"K""\xc4""MPFER/MAGIER/DIEB",
	"DIEB/MAGIER",
	"KLERIKER/DIEB",
	"K""\xc4""MPFER/KLER./MAG.",
	"WALDL./KLER.",
	"KLER./MAGIER",
	"K""\xc4""MPFER",
	"MAGIER",
	"KLERIKER",
	"DIEB",
	"PALADIN",
	"WALDL."
};

static const StringListProvider kEoB2ChargenClassStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2ChargenClassStringsAmigaGerman), kEoB2ChargenClassStringsAmigaGerman };

static const char *const kEoB2ChargenAlignmentStringsAmigaGerman[9] = {
	"RECHTSCH. GUT",
	"NEUTRAL GUT",
	"CHAOTISCH GUT",
	"RECHTSCH. NEUTRAL",
	"NEUTRAL",
	"CHAOTISCH NEUTRAL",
	"RECHTSCH. B""\xd6""SE",
	"NEUTRAL B""\xd6""SE",
	"CHAOTISCH B""\xd6""SE"
};

static const StringListProvider kEoB2ChargenAlignmentStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2ChargenAlignmentStringsAmigaGerman), kEoB2ChargenAlignmentStringsAmigaGerman };

static const char *const kEoB2ChargenEnterGameStringsAmigaGerman[1] = {
	"  Lade Spiel.\r  Bitte warten."
};

static const StringListProvider kEoB2ChargenEnterGameStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2ChargenEnterGameStringsAmigaGerman), kEoB2ChargenEnterGameStringsAmigaGerman };

static const char *const kEoB2PryDoorStringsAmigaGerman[9] = {
	"\r",
	"Ihr k""\xf6""nnt die T""\xfc""r nicht aufbrechen.\r",
	"\x06\x04""Ihr brecht die T""\xfc""r auf.\r",
	"\x06\x06""Ihr versucht vergeblich die T""\xfc""r gewaltsam zu\r""\xf6""ffnen.\r",
	"Das kann man hier nicht ablegen.\r",
	"Das passt hier nicht.\r",
	"Niemand kann die T""\xfc""r aufbrechen.\r",
	"\r",
	"\r"
};

static const StringListProvider kEoB2PryDoorStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2PryDoorStringsAmigaGerman), kEoB2PryDoorStringsAmigaGerman };

static const char *const kEoB2WarningStringsAmigaGerman[4] = {
	"Da geht's nicht lang.\r",
	"%s kann nichts zu sich nehmen!\r",
	"Das Zeug ist vergammelt! das will doch kein Mensch essen!\r",
	"Euch bekommt nur richtige Nahrung!\r"
};

static const StringListProvider kEoB2WarningStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2WarningStringsAmigaGerman), kEoB2WarningStringsAmigaGerman };

static const char *const kEoB2ItemSuffixStringsRingsAmigaGerman[4] = {
	"s Schmuckes",
	"r Zauberei",
	"r Nahrung",
	"s Federfalls"
};

static const StringListProvider kEoB2ItemSuffixStringsRingsAmigaGermanProvider = { ARRAYSIZE(kEoB2ItemSuffixStringsRingsAmigaGerman), kEoB2ItemSuffixStringsRingsAmigaGerman };

static const char *const kEoB2ItemSuffixStringsPotionsAmigaGerman[8] = {
	"r Riesenkraft",
	"r Heilung",
	"r Extra Heilung",
	"s Giftes",
	"r Lebenskraft",
	"r Geschwindigkeit",
	"r Unsichtbarkeit",
	"r Entgiftung"
};

static const StringListProvider kEoB2ItemSuffixStringsPotionsAmigaGermanProvider = { ARRAYSIZE(kEoB2ItemSuffixStringsPotionsAmigaGerman), kEoB2ItemSuffixStringsPotionsAmigaGerman };

static const char *const kEoB2ItemSuffixStringsWandsAmigaGerman[8] = {
	"r L""\xe4""hmung",
	"s Gewitters",
	"r K""\xe4""lte",
	"r Heilung",
	"s Feuerballs",
	"Sternenfeuer",
	"r Magischen Geschosse",
	"r gebannten magie"
};

static const StringListProvider kEoB2ItemSuffixStringsWandsAmigaGermanProvider = { ARRAYSIZE(kEoB2ItemSuffixStringsWandsAmigaGerman), kEoB2ItemSuffixStringsWandsAmigaGerman };

static const char *const kEoB2RipItemStringsAmigaGerman[4] = {
	"%s verlor: ",
	"%s verlor: ",
	".\r",
	"%d %s (verflucht)"
};

static const StringListProvider kEoB2RipItemStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2RipItemStringsAmigaGerman), kEoB2RipItemStringsAmigaGerman };

static const char *const kEoB2CursedStringAmigaGerman[1] = {
	"%d %s (verflucht) "
};

static const StringListProvider kEoB2CursedStringAmigaGermanProvider = { ARRAYSIZE(kEoB2CursedStringAmigaGerman), kEoB2CursedStringAmigaGerman };

static const char *const kEoB2MagicObjectStringsAmigaGerman[5] = {
	"Magierrolle",
	"Klerikerrolle",
	"Ring",
	"Trank",
	"Stab"
};

static const StringListProvider kEoB2MagicObjectStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2MagicObjectStringsAmigaGerman), kEoB2MagicObjectStringsAmigaGerman };

static const char *const kEoB2MagicObjectString5AmigaGerman[1] = {
	"Zepter"
};

static const StringListProvider kEoB2MagicObjectString5AmigaGermanProvider = { ARRAYSIZE(kEoB2MagicObjectString5AmigaGerman), kEoB2MagicObjectString5AmigaGerman };

static const char *const kEoB2PatternSuffixAmigaGerman[1] = {
	"%s de%s"
};

static const StringListProvider kEoB2PatternSuffixAmigaGermanProvider = { ARRAYSIZE(kEoB2PatternSuffixAmigaGerman), kEoB2PatternSuffixAmigaGerman };

static const char *const kEoB2PatternGrFix1AmigaGerman[1] = {
	"%s: %s"
};

static const StringListProvider kEoB2PatternGrFix1AmigaGermanProvider = { ARRAYSIZE(kEoB2PatternGrFix1AmigaGerman), kEoB2PatternGrFix1AmigaGerman };

static const char *const kEoB2PatternGrFix2AmigaGerman[1] = {
	"%s %s"
};

static const StringListProvider kEoB2PatternGrFix2AmigaGermanProvider = { ARRAYSIZE(kEoB2PatternGrFix2AmigaGerman), kEoB2PatternGrFix2AmigaGerman };

static const char *const kEoB2ValidateArmorStringAmigaGerman[1] = {
	"%s kann diese r""\xfc""stungsart nicht tragen.\r"
};

static const StringListProvider kEoB2ValidateArmorStringAmigaGermanProvider = { ARRAYSIZE(kEoB2ValidateArmorStringAmigaGerman), kEoB2ValidateArmorStringAmigaGerman };

static const char *const kEoB2ValidateCursedStringAmigaGerman[1] = {
	"%s kann die Waffe nicht loslassen! Sie ist verflucht!\r"
};

static const StringListProvider kEoB2ValidateCursedStringAmigaGermanProvider = { ARRAYSIZE(kEoB2ValidateCursedStringAmigaGerman), kEoB2ValidateCursedStringAmigaGerman };

static const char *const kEoB2ValidateNoDropStringAmigaGerman[1] = {
	"Diesen Gegenstand hier nicht ablegen.\r"
};

static const StringListProvider kEoB2ValidateNoDropStringAmigaGermanProvider = { ARRAYSIZE(kEoB2ValidateNoDropStringAmigaGerman), kEoB2ValidateNoDropStringAmigaGerman };

static const char *const kEoB2PotionStringsAmigaGerman[2] = {
	"vergiftet",
	"%s f""\xfc""hlt sich %s!\r"
};

static const StringListProvider kEoB2PotionStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2PotionStringsAmigaGerman), kEoB2PotionStringsAmigaGerman };

static const char *const kEoB2WandStringsAmigaGerman[1] = {
	"Der Stab hat offenbar keinen magischen Effekt\r"
};

static const StringListProvider kEoB2WandStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2WandStringsAmigaGerman), kEoB2WandStringsAmigaGerman };

static const char *const kEoB2ItemMisuseStringsAmigaGerman[3] = {
	"%s kann diesen Gegenstand nicht nutzen.\r",
	"Dieser Gegenstand wird automatisch beim Tragen benutzt.\r",
	"Das kann man so nicht benutzen.\r"
};

static const StringListProvider kEoB2ItemMisuseStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2ItemMisuseStringsAmigaGerman), kEoB2ItemMisuseStringsAmigaGerman };

static const char *const kEoB2TakenStringsAmigaGerman[1] = {
	" aufgenommen.\r"
};

static const StringListProvider kEoB2TakenStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2TakenStringsAmigaGerman), kEoB2TakenStringsAmigaGerman };

static const char *const kEoB2PotionEffectStringsAmigaGerman[8] = {
	"viel st""\xe4""rker",
	"besser",
	"viel besser",
	"etwas krank",
	"pappsatt",
	"schnell und agil",
	"transparent",
	"besser"
};

static const StringListProvider kEoB2PotionEffectStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2PotionEffectStringsAmigaGerman), kEoB2PotionEffectStringsAmigaGerman };

static const char *const kEoB2YesNoStringsAmigaGerman[2] = {
	"ja",
	"nein"
};

static const StringListProvider kEoB2YesNoStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2YesNoStringsAmigaGerman), kEoB2YesNoStringsAmigaGerman };

static const char *const kEoB2MoreStringsAmigaGerman[1] = {
	"MEHR"
};

static const StringListProvider kEoB2MoreStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2MoreStringsAmigaGerman), kEoB2MoreStringsAmigaGerman };

static const char *const kEoB2NpcMaxStringsAmigaGerman[1] = {
	"Maximal sechs Charaktere pro Party.  Wen wollt Ihr entlassen."
};

static const StringListProvider kEoB2NpcMaxStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2NpcMaxStringsAmigaGerman), kEoB2NpcMaxStringsAmigaGerman };

static const char *const kEoB2OkStringsAmigaGerman[1] = {
	"OK"
};

static const StringListProvider kEoB2OkStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2OkStringsAmigaGerman), kEoB2OkStringsAmigaGerman };

static const char *const kEoB2NpcJoinStringsAmigaGerman[1] = {
	"%s wird Partymitglied.\r"
};

static const StringListProvider kEoB2NpcJoinStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2NpcJoinStringsAmigaGerman), kEoB2NpcJoinStringsAmigaGerman };

static const char *const kEoB2CancelStringsAmigaGerman[1] = {
	"ABBR."
};

static const StringListProvider kEoB2CancelStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2CancelStringsAmigaGerman), kEoB2CancelStringsAmigaGerman };

static const char *const kEoB2AbortStringsAmigaGerman[1] = {
	"ABBR."
};

static const StringListProvider kEoB2AbortStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2AbortStringsAmigaGerman), kEoB2AbortStringsAmigaGerman };

static const char *const kEoB2MenuStringsMainAmigaGerman[8] = {
	"W""\xe4""hle Option:",
	"Rasten",
	"Spr""\xfc""che merken",
	"Um Spr""\xfc""che beten",
	"Rollen notieren",
	"Voreinstellungen",
	"Spieloptionen",
	"Ende"
};

static const StringListProvider kEoB2MenuStringsMainAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsMainAmigaGerman), kEoB2MenuStringsMainAmigaGerman };

static const char *const kEoB2MenuStringsSaveLoadAmigaGerman[8] = {
	"Spiel laden",
	"Spiel speichern",
	"Charakter entl.",
	"Beenden",
	"Spieloptionen:",
	"\r   Gespeichert.",
	"Speicherversuch\rfehlgeschlagen!",
	"Ladeversuch\rfehlgeschlagen.\rEvtl. Disk-Error!"
};

static const StringListProvider kEoB2MenuStringsSaveLoadAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsSaveLoadAmigaGerman), kEoB2MenuStringsSaveLoadAmigaGerman };

static const char *const kEoB2MenuStringsOnOffAmigaGerman[2] = {
	"AN",
	"AUS"
};

static const StringListProvider kEoB2MenuStringsOnOffAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsOnOffAmigaGerman), kEoB2MenuStringsOnOffAmigaGerman };

static const char *const kEoB2MenuStringsSpellsAmigaGerman[17] = {
	"\r\r W""\xe4""hlt einen Charak-\r ter aus der Party,\r der Spr""\xfc""che lernen\r soll.",
	"\r Der Paladin ist\r eine Stufe zu nied-\r rig zum zaubern.",
	"\r\r Der magier hat\r kein Spruchbuch!",
	"\r\r\r W""\xe4""hlt einen Charak-\r ter aus der Party,\r der f""\xfc""r Spr""\xfc""che\r beten will.",
	"\r Niemand in der\r Party ist in der\r Lage, f""\xfc""r Spr""\xfc""che\r zu beten.",
	"\r Niemand in der\r Party ist in der\r Lage, sich Spr""\xfc""che\r zu merken.",
	" Jemand der bewu""\xdf""t-\r los oder tot ist\r kann keine Spr""\xfc""che\r merken.",
	" Jemand der bewu""\xdf""t-\r los oder tot ist\r kann nicht um\r Spr""\xfc""che beten.",
	"1",
	"2",
	"3",
	"4",
	"5",
	"Neu",
	"Verf""\xfc""gbare Zauber:",
	"Ja",
	"Nein"
};

static const StringListProvider kEoB2MenuStringsSpellsAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsSpellsAmigaGerman), kEoB2MenuStringsSpellsAmigaGerman };

static const char *const kEoB2MenuStringsRestAmigaGerman[5] = {
	"\rWerden eure Heiler\rdie Party heilen?",
	" Jemand ist noch\r verletzt. Weiter-\r rasten?",
	"Die Party rastet.",
	"\r Alle Spieler\r sind voll\r ausgeruht.",
	" Eure Party braucht\r Rast, um Spr""\xfc""che\r zu erhalten."
};

static const StringListProvider kEoB2MenuStringsRestAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsRestAmigaGerman), kEoB2MenuStringsRestAmigaGerman };

static const char *const kEoB2MenuStringsDropAmigaGerman[1] = {
	" Weniger als vier\r Charaktere sind\r nicht erlaubt."
};

static const StringListProvider kEoB2MenuStringsDropAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsDropAmigaGerman), kEoB2MenuStringsDropAmigaGerman };

static const char *const kEoB2MenuStringsExitAmigaGerman[1] = {
	" Ganz bestimmt\r das Spiel\r abbrechen?"
};

static const StringListProvider kEoB2MenuStringsExitAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsExitAmigaGerman), kEoB2MenuStringsExitAmigaGerman };

static const char *const kEoB2MenuStringsStarveAmigaGerman[1] = {
	" Eure Party hungert.\r Wollt Ihr weiter\r rasten?"
};

static const StringListProvider kEoB2MenuStringsStarveAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsStarveAmigaGerman), kEoB2MenuStringsStarveAmigaGerman };

static const char *const kEoB2MenuStringsScribeAmigaGerman[5] = {
	"W""\xe4""hlt die Rolle(n)\rzum notieren.",
	"\r\r\r W""\xe4""hlt den Magier\r aus der Party,\r der Spr""\xfc""che\r notieren m""\xf6""chte.",
	" Ihr habt keine\r ""\xfc""bertragbaren\r Schriftrollen.",
	" Ihr habt keine\r Rollen, die dieser\r Magier braucht.",
	"\r Ihr habt keinen\r Magier, der Rollen\r ""\xfc""bertragen kann."
};

static const StringListProvider kEoB2MenuStringsScribeAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsScribeAmigaGerman), kEoB2MenuStringsScribeAmigaGerman };

static const char *const kEoB2MenuStringsDrop2AmigaGerman[3] = {
	" W""\xe4""hlt den Charak-\r ter, den Ihr\r entfernen m""\xf6""chtet.",
	" Spielst""\xe4""nde m""\xfc""ssen\r einen Namen haben!",
	" Ganz sicher den\r alten Spielstand\r ""\xfc""berschreiben?"
};

static const StringListProvider kEoB2MenuStringsDrop2AmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsDrop2AmigaGerman), kEoB2MenuStringsDrop2AmigaGerman };

static const char *const kEoB2MenuStringsHeadAmigaGerman[3] = {
	"Rast:",
	"Voreinstellung:",
	"Spieloptionen:"
};

static const StringListProvider kEoB2MenuStringsHeadAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsHeadAmigaGerman), kEoB2MenuStringsHeadAmigaGerman };

static const char *const kEoB2MenuStringsPoisonAmigaGerman[1] = {
	"Vergiftete Spieler\rk""\xf6""nnten sterben!\rTrotzdem rasten?"
};

static const StringListProvider kEoB2MenuStringsPoisonAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsPoisonAmigaGerman), kEoB2MenuStringsPoisonAmigaGerman };

static const char *const kEoB2MenuStringsMgcAmigaGerman[2] = {
	"%-18s %1d",
	"%d von %d verf""\xfc""gbar.  "
};

static const StringListProvider kEoB2MenuStringsMgcAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsMgcAmigaGerman), kEoB2MenuStringsMgcAmigaGerman };

static const char *const kEoB2MenuStringsPrefsAmigaGerman[4] = {
	"Musik ist %-3s",
	"FX sind %-3s",
	"Balkengrafik: %-3s",
	""
};

static const StringListProvider kEoB2MenuStringsPrefsAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsPrefsAmigaGerman), kEoB2MenuStringsPrefsAmigaGerman };

static const char *const kEoB2MenuStringsRest2AmigaGerman[5] = {
	"%s erhielt %s.\r",
	"%s merkt sich %s.\r",
	"%s heilt %s.\r",
	"Raststunden:   %-4d  ",
	"\r%s\r"
};

static const StringListProvider kEoB2MenuStringsRest2AmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsRest2AmigaGerman), kEoB2MenuStringsRest2AmigaGerman };

static const char *const kEoB2MenuStringsRest3AmigaGerman[1] = {
	"\x06\x06""Es scheint, als sei es nicht sicher hier zu rasten."
};

static const StringListProvider kEoB2MenuStringsRest3AmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsRest3AmigaGerman), kEoB2MenuStringsRest3AmigaGerman };

static const char *const kEoB2MenuStringsRest4AmigaGerman[1] = {
	"\x06\x06""In der N""\xe4""he von Monstern k""\xf6""nnt Ihr nicht rasten."
};

static const StringListProvider kEoB2MenuStringsRest4AmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsRest4AmigaGerman), kEoB2MenuStringsRest4AmigaGerman };

static const char *const kEoB2MenuStringsDefeatAmigaGerman[1] = {
	"\rDie gesamte Party\rwurde besiegt!\rEinen alten Spiel-\rstand laden?"
};

static const StringListProvider kEoB2MenuStringsDefeatAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsDefeatAmigaGerman), kEoB2MenuStringsDefeatAmigaGerman };

static const char *const kEoB2MenuStringsTransferAmigaGerman[5] = {
	"Mindestens vier\rSpieler vor Spiel-\rbeginn transferieren!",
	"Nur vier Spieler\rtransferieren!",
	"Bestimmte Habselig-\rkeiten werden\rgel""\xf6""scht.",
	" \r Kein Magier in\r der Party.",
	" \r Kein Kleriker\r oder Paladin\r in der Party."
};

static const StringListProvider kEoB2MenuStringsTransferAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsTransferAmigaGerman), kEoB2MenuStringsTransferAmigaGerman };

static const char *const kEoB2MenuStringsSpecAmigaGerman[2] = {
	"Beim Aufwachen bem-\rerkt Ihr die Ab-\rwesenheit von Insal!",
	"Eine kurzer Blick\rzeigt, das Ausr""\xfc""st-\rung gestohlen wurde!"
};

static const StringListProvider kEoB2MenuStringsSpecAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuStringsSpecAmigaGerman), kEoB2MenuStringsSpecAmigaGerman };

static const char *const kEoB2MenuYesNoStringsAmigaGerman[2] = {
	"Ja",
	"Nein"
};

static const StringListProvider kEoB2MenuYesNoStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2MenuYesNoStringsAmigaGerman), kEoB2MenuYesNoStringsAmigaGerman };

static const char *const kEoB2CharGuiStringsHpAmigaGerman[2] = {
	"TP",
	"%3d / %-3d"
};

static const StringListProvider kEoB2CharGuiStringsHpAmigaGermanProvider = { ARRAYSIZE(kEoB2CharGuiStringsHpAmigaGerman), kEoB2CharGuiStringsHpAmigaGerman };

static const char *const kEoB2CharGuiStringsWp2AmigaGerman[3] = {
	"WUSCH",
	"HACK",
	"FATZ"
};

static const StringListProvider kEoB2CharGuiStringsWp2AmigaGermanProvider = { ARRAYSIZE(kEoB2CharGuiStringsWp2AmigaGerman), kEoB2CharGuiStringsWp2AmigaGerman };

static const char *const kEoB2CharGuiStringsWrAmigaGerman[4] = {
	" ZU ",
	"WEIT",
	"OHNE",
	"MUN"
};

static const StringListProvider kEoB2CharGuiStringsWrAmigaGermanProvider = { ARRAYSIZE(kEoB2CharGuiStringsWrAmigaGerman), kEoB2CharGuiStringsWrAmigaGerman };

static const char *const kEoB2CharGuiStringsSt2AmigaGerman[7] = {
	"TAUSCHE",
	"TOT",
	"BEWUSSTLOS",
	"GIFT (LANGSAM)",
	"VERGIFTET",
	"BET""\xc4""UBT",
	"AUS STEIN"
};

static const StringListProvider kEoB2CharGuiStringsSt2AmigaGermanProvider = { ARRAYSIZE(kEoB2CharGuiStringsSt2AmigaGerman), kEoB2CharGuiStringsSt2AmigaGerman };

static const char *const kEoB2CharGuiStringsInAmigaGerman[4] = {
	"CHARAKTER INFO",
	"R""\xdc""STUNGSKL.",
	"ERF",
	"STF"
};

static const StringListProvider kEoB2CharGuiStringsInAmigaGermanProvider = { ARRAYSIZE(kEoB2CharGuiStringsInAmigaGerman), kEoB2CharGuiStringsInAmigaGerman };

static const char *const kEoB2CharStatusStrings7AmigaGerman[1] = {
	"%s hat nicht l""\xe4""nger riesenkr""\xe4""fte.\r"
};

static const StringListProvider kEoB2CharStatusStrings7AmigaGermanProvider = { ARRAYSIZE(kEoB2CharStatusStrings7AmigaGerman), kEoB2CharStatusStrings7AmigaGerman };

static const char *const kEoB2CharStatusStrings82AmigaGerman[1] = {
	"\x06\x06""%s f""\xfc""hlt Gift in sich!\r"
};

static const StringListProvider kEoB2CharStatusStrings82AmigaGermanProvider = { ARRAYSIZE(kEoB2CharStatusStrings82AmigaGerman), kEoB2CharStatusStrings82AmigaGerman };

static const char *const kEoB2CharStatusStrings9AmigaGerman[1] = {
	"\x06\x04""%s ist nicht l""\xe4""nger bet""\xe4""ubt!\r"
};

static const StringListProvider kEoB2CharStatusStrings9AmigaGermanProvider = { ARRAYSIZE(kEoB2CharStatusStrings9AmigaGerman), kEoB2CharStatusStrings9AmigaGerman };

static const char *const kEoB2CharStatusStrings12AmigaGerman[1] = {
	"%s wird langsamer.\r"
};

static const StringListProvider kEoB2CharStatusStrings12AmigaGermanProvider = { ARRAYSIZE(kEoB2CharStatusStrings12AmigaGerman), kEoB2CharStatusStrings12AmigaGerman };

static const char *const kEoB2CharStatusStrings132AmigaGerman[1] = {
	"\x06\x06""%s %s!\r"
};

static const StringListProvider kEoB2CharStatusStrings132AmigaGermanProvider = { ARRAYSIZE(kEoB2CharStatusStrings132AmigaGerman), kEoB2CharStatusStrings132AmigaGerman };

static const char *const kEoB2LevelGainStringsAmigaGerman[1] = {
	"\x06\x01""%s steigt eine Stufe auf.""\x06\x0f""\r"
};

static const StringListProvider kEoB2LevelGainStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2LevelGainStringsAmigaGerman), kEoB2LevelGainStringsAmigaGerman };

static const char *const kEoB2BookNumbersAmigaGerman[5] = {
	"Erste",
	"Zweite",
	"Dritte",
	"Vierte",
	"F""\xfc""nfte"
};

static const StringListProvider kEoB2BookNumbersAmigaGermanProvider = { ARRAYSIZE(kEoB2BookNumbersAmigaGerman), kEoB2BookNumbersAmigaGerman };

static const char *const kEoB2MageSpellsListAmigaGerman[33] = {
	"",
	"Panzer",
	"Brennende H""\xe4""nde",
	"Magie entdecken",
	"Magisch. Geschoss",
	"Schild",
	"Schockgriff",
	"Verschwimmen",
	"Unsichtb. entd.",
	"Identifiziern+",
	"Unsichtbarkeit",
	"M's S""\xe4""urepfeil",
	"Magie bannen",
	"Feuerball",
	"Hast",
	"Person halten",
	"Unsichtb. 3m",
	"Blitzstrahl",
	"Vampirgriff",
	"Furcht",
	"Eissturm",
	"Unsichtbarkeit+",
	"Fluch brechen",
	"K""\xe4""ltekegel",
	"Monster halten",
	"Kraftfeld",
	"Aufl""\xf6""sung",
	"Fleisch zu Stein",
	"Stein zu Fleisch",
	"Wahrer Blick",
	"Todesfinger",
	"Wort:Bet""\xe4""ubung",
	"Bigbys Faust"
};

static const StringListProvider kEoB2MageSpellsListAmigaGermanProvider = { ARRAYSIZE(kEoB2MageSpellsListAmigaGerman), kEoB2MageSpellsListAmigaGerman };

static const char *const kEoB2ClericSpellsListAmigaGerman[30] = {
	"",
	"Segen",
	"Leicht verwunden",
	"L. Wunden heilen",
	"Magie entdecken",
	"Schutz v. B""\xf6""sem",
	"St""\xe4""rkung",
	"Flammenklinge",
	"Person halten",
	"Gift verlangs.",
	"Nahr. erschaffen",
	"Magie bannen",
	"Schutzgewand",
	"Gebet",
	"L""\xe4""hmung aufheben",
	"Schwer verwunden",
	"S. Wunden heilen",
	"Gift neutr.",
	"Schutz-B""\xf6""ses 3m",
	"Kritisch verw.",
	"K. Wunden heilen",
	"Flammenschlag",
	"Tote erwecken",
	"Schneller Tod",
	"Wahrer Blick",
	"Leid",
	"Heilung",
	"Auferstehung",
	"Handauflegen",
	"Untote abwenden"
};

static const StringListProvider kEoB2ClericSpellsListAmigaGermanProvider = { ARRAYSIZE(kEoB2ClericSpellsListAmigaGerman), kEoB2ClericSpellsListAmigaGerman };

static const char *const kEoB2SpellNamesAmigaGerman[68] = {
	"panzer",
	"brennende H""\xe4""nde",
	"magie entdecken",
	"magisches Geschoss",
	"schild",
	"schockgriff",
	"verschwimmen",
	"unsichtbares entdecken",
	"verbessertes identifizieren",
	"unsichtbarkeit",
	"melfs S""\xe4""urepfeil",
	"magie bannen",
	"feuerball",
	"hast",
	"person halten",
	"unsichtbarkeit 3m",
	"blitzschlag",
	"vampirgriff",
	"furcht",
	"eissturm",
	"verbesserte Unsichtbarkeit",
	"fluch brechen",
	"k""\xe4""ltekegel",
	"monster halten",
	"kraftfeld",
	"aufl""\xf6""sung",
	"fleisch zu stein",
	"stein zu fleisch",
	"wahrer Blick",
	"Todesfinger",
	"wort der Macht: Bet""\xe4""ubung",
	"bigbys geballte Faust",
	"segen",
	"leichte Wunden verursachen",
	"leichte Wunden heilen",
	"magie entdecken",
	"schutz vor B""\xf6""sem",
	"st""\xe4""rkung",
	"flammenklinge",
	"person halten",
	"gift verlangsamen",
	"nahrung erschaffen",
	"magie bannen",
	"schutzgewand",
	"gebet",
	"l""\xe4""hmung aufheben",
	"schwere wunden verursachen",
	"schwere wunden heilen",
	"gift neutralisieren",
	"schutz vor b""\xf6""sem 3m",
	"kritische wunden verursachen",
	"kritische wunden heilen",
	"flammenschlag",
	"tote erwecken",
	"schneller tot",
	"wahrer blick",
	"leid",
	"heilung",
	"auferstehung",
	"hand auflegen",
	"untote abwenden",
	"",
	"mystische abwehr",
	"",
	"",
	"",
	"",
	""
};

static const StringListProvider kEoB2SpellNamesAmigaGermanProvider = { ARRAYSIZE(kEoB2SpellNamesAmigaGerman), kEoB2SpellNamesAmigaGerman };

static const char *const kEoB2MagicStrings1AmigaGerman[6] = {
	"ABBRECHEN",
	"ABBRECHEN",
	"Man braucht eine freie Hand f""\xfc""r diesen Zauber.\r",
	"Von diesen Zaubern kann man nur einen aktivieren.\r",
	"%s zaubert %s.\r",
	"\rok\r"
};

static const StringListProvider kEoB2MagicStrings1AmigaGermanProvider = { ARRAYSIZE(kEoB2MagicStrings1AmigaGerman), kEoB2MagicStrings1AmigaGerman };

static const char *const kEoB2MagicStrings2AmigaGerman[5] = {
	"Der Zauber versagt!\r",
	"%s wurde aufgel""\xf6""st!\r",
	"\x06\x06""Die Party wurde von einem Todeszauber getroffen!\r",
	"\x06\x06""%s wurde von einem schwer verwunden Zauber getroffen.\r",
	"AUS STEIN"
};

static const StringListProvider kEoB2MagicStrings2AmigaGermanProvider = { ARRAYSIZE(kEoB2MagicStrings2AmigaGerman), kEoB2MagicStrings2AmigaGerman };

static const char *const kEoB2MagicStrings3AmigaGerman[5] = {
	"Wen verzaubern? ",
	"\rSpruch abgebrochen.\r",
	"%s's %s Zauber l""\xe4""sst nach.\r",
	"%s verfehlt das Monster.\r",
	"%s muss vorn stehen um zu treffen!\r"
};

static const StringListProvider kEoB2MagicStrings3AmigaGermanProvider = { ARRAYSIZE(kEoB2MagicStrings3AmigaGerman), kEoB2MagicStrings3AmigaGerman };

static const char *const kEoB2MagicStrings4AmigaGerman[1] = {
	"keine Wirkung.\r"
};

static const StringListProvider kEoB2MagicStrings4AmigaGermanProvider = { ARRAYSIZE(kEoB2MagicStrings4AmigaGerman), kEoB2MagicStrings4AmigaGerman };

static const char *const kEoB2MagicStrings6AmigaGerman[1] = {
	"%s hat schon eine R""\xfc""stungklasse ""\xfc""ber 6."
};

static const StringListProvider kEoB2MagicStrings6AmigaGermanProvider = { ARRAYSIZE(kEoB2MagicStrings6AmigaGerman), kEoB2MagicStrings6AmigaGerman };

static const char *const kEoB2MagicStrings7AmigaGerman[2] = {
	"%s steht schon unter dem effekt eines %s spruches.\r",
	"die party steht schon unter dem effekt eines %s spruches.\r"
};

static const StringListProvider kEoB2MagicStrings7AmigaGermanProvider = { ARRAYSIZE(kEoB2MagicStrings7AmigaGerman), kEoB2MagicStrings7AmigaGerman };

static const char *const kEoB2MagicStrings8AmigaGerman[6] = {
	"Der Zauber versagt!\r",
	"ist gel""\xe4""hmt",
	"Der Zauber versagt!\r",
	"Der Zauber versagt!\r",
	"Kein Monster in Reichweite!\r",
	"%s steht bereits unter einem St""\xe4""rkungszauber.\r"
};

static const StringListProvider kEoB2MagicStrings8AmigaGermanProvider = { ARRAYSIZE(kEoB2MagicStrings8AmigaGerman), kEoB2MagicStrings8AmigaGerman };

static const byte kEoB2ManDefAmigaGerman[200] = {
	0x09, 0x01, 0x03, 0x00, 0x09, 0x01, 0x06, 0x00,
	0x09, 0x02, 0x07, 0x00, 0x14, 0x01, 0x01, 0x00,
	0x14, 0x02, 0x01, 0x00, 0x14, 0x04, 0x02, 0x00,
	0x1A, 0x01, 0x03, 0x00, 0x1A, 0x02, 0x02, 0x00,
	0x1A, 0x07, 0x04, 0x00, 0x15, 0x01, 0x02, 0x00,
	0x15, 0x01, 0x05, 0x00, 0x15, 0x02, 0x01, 0x00,
	0x15, 0x03, 0x04, 0x00, 0x15, 0x04, 0x01, 0x00,
	0x15, 0x05, 0x05, 0x00, 0x23, 0x01, 0x02, 0x00,
	0x23, 0x01, 0x05, 0x00, 0x23, 0x02, 0x03, 0x00,
	0x23, 0x03, 0x01, 0x00, 0x23, 0x06, 0x03, 0x00,
	0x23, 0x0A, 0x06, 0x00, 0x26, 0x01, 0x01, 0x00,
	0x26, 0x01, 0x03, 0x00, 0x26, 0x01, 0x05, 0x00,
	0x26, 0x02, 0x04, 0x00, 0x26, 0x03, 0x02, 0x00,
	0x26, 0x04, 0x01, 0x00, 0x17, 0x01, 0x02, 0x00,
	0x17, 0x01, 0x04, 0x00, 0x17, 0x01, 0x05, 0x00,
	0x17, 0x02, 0x02, 0x00, 0x17, 0x03, 0x03, 0x00,
	0x17, 0x07, 0x01, 0x00, 0x12, 0x01, 0x02, 0x00,
	0x12, 0x01, 0x07, 0x00, 0x12, 0x03, 0x01, 0x00,
	0x12, 0x04, 0x02, 0x00, 0x12, 0x05, 0x02, 0x00,
	0x12, 0x06, 0x05, 0x00, 0x12, 0x07, 0x03, 0x00,
	0x12, 0x08, 0x01, 0x00, 0x1F, 0x01, 0x05, 0x00,
	0x1F, 0x02, 0x06, 0x00, 0x1F, 0x03, 0x02, 0x00,
	0x1F, 0x03, 0x01, 0x00, 0x1F, 0x04, 0x01, 0x00,
	0x1F, 0x04, 0x03, 0x00, 0x1C, 0x01, 0x01, 0x00,
	0x1C, 0x01, 0x03, 0x00, 0x1C, 0x02, 0x01, 0x00
};

static const ByteProvider kEoB2ManDefAmigaGermanProvider = { ARRAYSIZE(kEoB2ManDefAmigaGerman), kEoB2ManDefAmigaGerman };

static const char *const kEoB2ManWordAmigaGerman[51] = {
	"teil",
	"geht",
	"maus",
	"um",
	"einer",
	"kann",
	"das",
	"schalter",
	"der",
	"einem",
	"gnome",
	"magieresistent",
	"intelligenz",
	"weisheit",
	"dieb",
	"weiter",
	"setzen",
	"ein",
	"magier",
	"diese",
	"sind",
	"eines",
	"wodurch",
	"schwerer",
	"gute",
	"bonus",
	"bogen",
	"und",
	"dadurch",
	"oft",
	"raubt",
	"keine",
	"schrift",
	"waffen",
	"unterteilt",
	"vordersten",
	"nur",
	"sie",
	"klassen",
	"zeigt",
	"gegen",
	"mausknopf",
	"nahrungsbalken",
	"charakters",
	"des",
	"um",
	"gegenstand",
	"durch",
	"spruch",
	"unsichtbar",
	""
};

static const StringListProvider kEoB2ManWordAmigaGermanProvider = { ARRAYSIZE(kEoB2ManWordAmigaGerman), kEoB2ManWordAmigaGerman };

static const char *const kEoB2ManPromptAmigaGerman[1] = {
	"\r\r\r\rAuf der Seite mit diesem Symbol...\r\rFinde Zeile %d\rGib Wort %d ein\r"
};

static const StringListProvider kEoB2ManPromptAmigaGermanProvider = { ARRAYSIZE(kEoB2ManPromptAmigaGerman), kEoB2ManPromptAmigaGerman };

static const char *const kEoB2MainMenuStringsAmigaGerman[5] = {
	"ALTES SPIEL LADEN\r",
	"NEUE PARTY ERSTELLEN\r",
	"EOB I PARTY TRANSFER\r",
	"INTRO ANSEHEN\r",
	"FORMATIEREN\r"
};

static const StringListProvider kEoB2MainMenuStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2MainMenuStringsAmigaGerman), kEoB2MainMenuStringsAmigaGerman };

static const char *const kEoB2TransferStrings1AmigaGerman[2] = {
	"Stufe: %d",
	" / %d"
};

static const StringListProvider kEoB2TransferStrings1AmigaGermanProvider = { ARRAYSIZE(kEoB2TransferStrings1AmigaGerman), kEoB2TransferStrings1AmigaGerman };

static const char *const kEoB2TransferStrings2AmigaGerman[2] = {
	"Dieses Abenteuer ist nur f""\xfc""r vier Charaktere.",
	"OK w""\xe4""hlen, wenn Partyerstellung beendet."
};

static const StringListProvider kEoB2TransferStrings2AmigaGermanProvider = { ARRAYSIZE(kEoB2TransferStrings2AmigaGerman), kEoB2TransferStrings2AmigaGerman };

static const char *const kEoB2TransferLabelsAmigaGerman[2] = {
	"ABBR.",
	"OK"
};

static const StringListProvider kEoB2TransferLabelsAmigaGermanProvider = { ARRAYSIZE(kEoB2TransferLabelsAmigaGerman), kEoB2TransferLabelsAmigaGerman };

static const char *const kEoB2IntroStringsAmigaGerman[20] = {
	"Ihr hattet euch gerade gem""\xfc""tlich am \rKamin niedergelassen.",
	"Da wurde euch eine Botschaft\rzugespielt.",
	"Sie war von eurem Freund Khelben \rBlackstaff, dem Erzmagier der Stadt.",
	"Die Mitteilung war dringend.",
	"Was konnte Khelben nur wollen?",
	"Willkommen, bitte tretet ein.",
	"Khelben erwartet euch im Studierzimmer.",
	"Danke f""\xfc""r euer schnelles Kommen.",
	"Meine Freunde, ich bin besorgt.",
	"Uralte, b""\xf6""se M""\xe4""chte rumoren im \rTempel Darkmoon.",
	"Ich f""\xfc""rchte um die Sicherheit \runserer Stadt.",
	"Ich brauche eure Hilfe...",
	"Vor drei N""\xe4""chten \rentsandte ich einen Kundschafter.",
	"Sie kam niemals zur""\xfc""ck.",
	"Ich f""\xfc""rchte um ihr Leben.",
	"Nehmt diese M""\xfc""nze.",
	"Mit ihrer Hilfe werde \rich euch erreichen.",
	"Ihr m""\xfc\xdf""t schnell handeln.",
	"Ich teleportiere euch nun in \rdie N""\xe4""he von Darkmoon.",
	"M""\xf6""ge das Gl""\xfc""ck auf eurer Seite\rsein, Freunde."
};

static const StringListProvider kEoB2IntroStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2IntroStringsAmigaGerman), kEoB2IntroStringsAmigaGerman };

static const char *const kEoB2IntroCPSFilesAmigaGerman[16] = {
	"STREET1.CPS",
	"STREET2.CPS",
	"DOORWAY1.CPS",
	"DOORWAY2.CPS",
	"WESTWOOD1.CPS",
	"WINDING.CPS",
	"KHELBAN2.CPS",
	"KHELBAN1.CPS",
	"KHELBAN3.CPS",
	"KHELBAN4.CPS",
	"COIN.CPS",
	"KHELBAN5.CPS",
	"KHELBAN6.CPS",
	"WESTWOOD1.CPS",
	"WESTWOOD3.CPS",
	"WESTWOOD3.CPS"
};

static const StringListProvider kEoB2IntroCPSFilesAmigaGermanProvider = { ARRAYSIZE(kEoB2IntroCPSFilesAmigaGerman), kEoB2IntroCPSFilesAmigaGerman };

static const char *const kEoB2FinaleStringsAmigaGerman[20] = {
	"Nun endlich wurde Dran besiegt.",
	"Pl""\xf6""tzlich erscheint euer Freund \rKhelben.",
	"Seid gegr""\xfc\xdf""t, meine siegreichen \rFreunde.",
	"Ihr seid die Bezwinger von Dran!",
	"Ich hatte keine Ahnung, da""\xdf"" \rDran ein Drache war.",
	"Er mu""\xdf"" ""\xfc""ber 300 Jahre alt \rgewesen sein!",
	"Seine Macht ist vergangen.",
	"Noch immer ist Darkmoon\reine Quelle des B""\xf6""sen.",
	"Und ein Teil seines Gefolges\rexistiert noch.",
	"Daher m""\xfc""ssen wir diesen Platz\rnun verlassen.",
	"So da""\xdf"" meine Kr""\xe4""fte ihn ein\r f""\xfc""r allemal\rzerst""\xf6""ren k""\xf6""nnen.",
	"Folgt mir.",
	"M""\xe4""chtige Magier sind bereit\rf""\xfc""r den letzten Schlag\rgegen Darkmoon.",
	"Das B""\xf6""se im Tempel ist sehr stark.",
	"Es darf keinesfalls weiter\rbestehen!",
	"Der Tempel h""\xf6""rt auf zu\rexistieren.",
	"Unsere Arbeit ist nun getan,\rmeine Freunde.",
	"Seid bedankt.",
	"Ihr habt Euch meinen tiefen\r Respekt erk""\xe4""mpft.",
	"Wir werden Euch nie vergessen."
};

static const StringListProvider kEoB2FinaleStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2FinaleStringsAmigaGerman), kEoB2FinaleStringsAmigaGerman };

static const char *const kEoB2FinaleCPSFilesAmigaGerman[13] = {
	"DRAGON1.CPS",
	"DRAGON2.CPS",
	"HURRY1.CPS",
	"HURRY2.CPS",
	"DESTROY0.CPS",
	"DESTROY1.CPS",
	"DESTROY2.CPS",
	"MAGIC.CPS",
	"DESTROY3.CPS",
	"CREDITS2.CPS",
	"CREDITS3.CPS",
	"HEROES.CPS",
	"THANKS.CPS"
};

static const StringListProvider kEoB2FinaleCPSFilesAmigaGermanProvider = { ARRAYSIZE(kEoB2FinaleCPSFilesAmigaGerman), kEoB2FinaleCPSFilesAmigaGerman };

static const char *const kEoB2MonsterDistAttStringsAmigaGerman[5] = {
	"Die Party wurde von einem psychischen Angriff getroffen!\r",
	"paralysiert",
	"vergiftet",
	"bet""\xe4""ubt",
	"versteinert"
};

static const StringListProvider kEoB2MonsterDistAttStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2MonsterDistAttStringsAmigaGerman), kEoB2MonsterDistAttStringsAmigaGerman };

static const char *const kEoB2Npc1StringsAmigaGerman[2] = {
	"reden",
	"weiter"
};

static const StringListProvider kEoB2Npc1StringsAmigaGermanProvider = { ARRAYSIZE(kEoB2Npc1StringsAmigaGerman), kEoB2Npc1StringsAmigaGerman };

static const char *const kEoB2Npc2StringsAmigaGerman[2] = {
	"freilassen",
	"weiterziehen"
};

static const StringListProvider kEoB2Npc2StringsAmigaGermanProvider = { ARRAYSIZE(kEoB2Npc2StringsAmigaGerman), kEoB2Npc2StringsAmigaGerman };

static const char *const kEoB2MonsterDustStringsAmigaGerman[1] = {
	"Das Monster vergeht zu staub!\r"
};

static const StringListProvider kEoB2MonsterDustStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2MonsterDustStringsAmigaGerman), kEoB2MonsterDustStringsAmigaGerman };

static const char *const kEoB2KheldranStringsAmigaGerman[1] = {
	"    Diese Narren!"
};

static const StringListProvider kEoB2KheldranStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2KheldranStringsAmigaGerman), kEoB2KheldranStringsAmigaGerman };

static const char *const kEoB2HornStringsAmigaGerman[4] = {
	"Ein br""\xfc""llendes Ger""\xe4""usch kommt aus dem Horn.\r",
	"Ein hohler Ton dringt aus dem Horn.\r",
	"Ein melodischer Ton klingt aus dem Horn.\r",
	"Ein unheimliches Ger""\xe4""usch entweicht dem Horn.\r"
};

static const StringListProvider kEoB2HornStringsAmigaGermanProvider = { ARRAYSIZE(kEoB2HornStringsAmigaGerman), kEoB2HornStringsAmigaGerman };