static const char *const kEoB1ChargenStrings1DOSGerman[9] = {
	"Ihr Team ist\rkomplett. SPIEL-\rKnopf oder 'P'\rdruecken, um zu\rbeginnen.",
	"          ",
	"RK\rHP\rEBN",
	"%s\r%d\r%d\r%d\r%d\r%d",
	"%d\r%d",
	"%d",
	"%d/%d",
	"%d/%d/%d",
	"Waehle das Feld\rdes Charakters\rzum erstellen oder\ranschauen."
};

static const StringListProvider kEoB1ChargenStrings1DOSGermanProvider = { ARRAYSIZE(kEoB1ChargenStrings1DOSGerman), kEoB1ChargenStrings1DOSGerman };

static const char *const kEoB1ChargenStrings2DOSGerman[12] = {
	"%s",
	"%d",
	"%s",
	"%d",
	"%d",
	"%d",
	"%s",
	"%d",
	"WAEHLE RASSE:",
	"WAEHLE KLASSE:",
	"GESINNUNG WAEHLEN:",
	"Name:"
};

static const StringListProvider kEoB1ChargenStrings2DOSGermanProvider = { ARRAYSIZE(kEoB1ChargenStrings2DOSGerman), kEoB1ChargenStrings2DOSGerman };

static const char *const kEoB1ChargenStatStringsDOSGerman[12] = {
	"STR",
	"INT",
	"WEI",
	"GEW",
	"KON",
	"CHA",
	"STAERKE",
	"INTELLIGENZ",
	"WEISHEIT",
	"GEWANDHEIT",
	"KONSTITUTION",
	"CHARISMA"
};

static const StringListProvider kEoB1ChargenStatStringsDOSGermanProvider = { ARRAYSIZE(kEoB1ChargenStatStringsDOSGerman), kEoB1ChargenStatStringsDOSGerman };

static const char *const kEoB1ChargenRaceSexStringsDOSGerman[12] = {
	"MENSCH MAENNL.",
	"MENSCH WEIBL.",
	"ELF MAENNL.",
	"ELF WEIBL.",
	"HALB-ELF MAENNL.",
	"HALB-ELF WEIBL.",
	"ZWERG MAENNL.",
	"ZWERG WEIBL.",
	"GNOM MAENNL.",
	"GNOM WEIBL.",
	"HALBLING MAENNL.",
	"HALBLING WEIBL."
};

static const StringListProvider kEoB1ChargenRaceSexStringsDOSGermanProvider = { ARRAYSIZE(kEoB1ChargenRaceSexStringsDOSGerman), kEoB1ChargenRaceSexStringsDOSGerman };

static const char *const kEoB1ChargenClassStringsDOSGerman[21] = {
	"KAEMPFER",
	"WALDLAEUFER",
	"PALADIN",
	"MAGIER",
	"KLERIKER",
	"DIEB",
	"KAEMPFER/KLERIKER",
	"KAEMPFER/DIEB",
	"KAEMPFER/MAGIER",
	"KAEMPF./MAGIER/DIEB",
	"DIEB/MAGIER",
	"KLERIKER/DIEB",
	"KAEMPF./KLE./MAGIER",
	"WALDLAEUF./KLERIKER",
	"KLERIKER/MAGIER",
	"KAEMPFER",
	"MAGIER",
	"KLERIKER",
	"DIEB",
	"PALADIN",
	"WALDLAEUFER"
};

static const StringListProvider kEoB1ChargenClassStringsDOSGermanProvider = { ARRAYSIZE(kEoB1ChargenClassStringsDOSGerman), kEoB1ChargenClassStringsDOSGerman };

static const char *const kEoB1ChargenAlignmentStringsDOSGerman[9] = {
	"RECHTSCH. GUT",
	"NEUTRAL GUT",
	"CHAOTISCH GUT",
	"RECHTSCH. NEUTRAL",
	"ABSOLUT NEUTRAL",
	"CHAOTISCH NEUTRAL",
	"RECHTSCH. BOESE",
	"NEUTRAL BOESE",
	"CHAOTISCH BOESE"
};

static const StringListProvider kEoB1ChargenAlignmentStringsDOSGermanProvider = { ARRAYSIZE(kEoB1ChargenAlignmentStringsDOSGerman), kEoB1ChargenAlignmentStringsDOSGerman };

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

static const StringListProvider kEoB1ChargenEnterGameStringsDOSGermanProvider = { ARRAYSIZE(kEoB1ChargenEnterGameStringsDOSGerman), kEoB1ChargenEnterGameStringsDOSGerman };

static const char *const kEoB1MainMenuStringsDOSGerman[3] = {
	"ALTES SPIEL LADEN\r",
	"NEUES TEAM AUFBAUEN\r",
	"ENDE > DOS\r"
};

static const StringListProvider kEoB1MainMenuStringsDOSGermanProvider = { ARRAYSIZE(kEoB1MainMenuStringsDOSGerman), kEoB1MainMenuStringsDOSGerman };

static const char *const kEoB1BonusStringsDOSGerman[3] = {
	"Herzlichen Glueckwunsch fuer das Auffinden aller 12 Beholder-Boni.\r\rDie beteiligten Charaktere des gluecklichen Teams waren:\r\r",
	"\r",
	"\r\rPasswort: %04x\r"
};

static const StringListProvider kEoB1BonusStringsDOSGermanProvider = { ARRAYSIZE(kEoB1BonusStringsDOSGerman), kEoB1BonusStringsDOSGerman };

static const char *const kEoB1TurnUndeadStringDOSGerman[1] = {
	"\x06\x06""%s benutzt Magie, um Untote zu vertreiben!""\x06\x0F""\r"
};

static const StringListProvider kEoB1TurnUndeadStringDOSGermanProvider = { ARRAYSIZE(kEoB1TurnUndeadStringDOSGerman), kEoB1TurnUndeadStringDOSGerman };

static const char *const kEoB1Npc0StringsDOSGerman[2] = {
	"\r     Ich wuensche Euch Glueck auf Euren Reisen.",
	"Wer soll wiedererweckt werden?"
};

static const StringListProvider kEoB1Npc0StringsDOSGermanProvider = { ARRAYSIZE(kEoB1Npc0StringsDOSGerman), kEoB1Npc0StringsDOSGerman };

static const char *const kEoB1Npc11StringsDOSGerman[3] = {
	"Wunden heilen",
	"Reden",
	"Gehen"
};

static const StringListProvider kEoB1Npc11StringsDOSGermanProvider = { ARRAYSIZE(kEoB1Npc11StringsDOSGerman), kEoB1Npc11StringsDOSGerman };

static const char *const kEoB1Npc12StringsDOSGerman[2] = {
	"Wunden heilen",
	"Gehen"
};

static const StringListProvider kEoB1Npc12StringsDOSGermanProvider = { ARRAYSIZE(kEoB1Npc12StringsDOSGerman), kEoB1Npc12StringsDOSGerman };

static const char *const kEoB1Npc21StringsDOSGerman[2] = {
	"Angebot hoeren",
	"Gehen"
};

static const StringListProvider kEoB1Npc21StringsDOSGermanProvider = { ARRAYSIZE(kEoB1Npc21StringsDOSGerman), kEoB1Npc21StringsDOSGerman };

static const char *const kEoB1Npc22StringsDOSGerman[2] = {
	"Helfen",
	"Gehen"
};

static const StringListProvider kEoB1Npc22StringsDOSGermanProvider = { ARRAYSIZE(kEoB1Npc22StringsDOSGerman), kEoB1Npc22StringsDOSGerman };

static const char *const kEoB1Npc31StringsDOSGerman[2] = {
	"Team heilen",
	"Gehen"
};

static const StringListProvider kEoB1Npc31StringsDOSGermanProvider = { ARRAYSIZE(kEoB1Npc31StringsDOSGerman), kEoB1Npc31StringsDOSGerman };

static const char *const kEoB1Npc32StringsDOSGerman[3] = {
	"Team heilen",
	"Tote erwecken",
	"Gehen"
};

static const StringListProvider kEoB1Npc32StringsDOSGermanProvider = { ARRAYSIZE(kEoB1Npc32StringsDOSGerman), kEoB1Npc32StringsDOSGerman };

static const char *const kEoB1Npc4StringsDOSGerman[2] = {
	"Angreifen",
	"Bestechen"
};

static const StringListProvider kEoB1Npc4StringsDOSGermanProvider = { ARRAYSIZE(kEoB1Npc4StringsDOSGerman), kEoB1Npc4StringsDOSGerman };

static const char *const kEoB1Npc5StringsDOSGerman[3] = {
	"toeten",
	"anhoeren",
	"gehen lassen"
};

static const StringListProvider kEoB1Npc5StringsDOSGermanProvider = { ARRAYSIZE(kEoB1Npc5StringsDOSGerman), kEoB1Npc5StringsDOSGerman };

static const char *const kEoB1Npc6StringsDOSGerman[2] = {
	"Ergeben",
	"Angreifen"
};

static const StringListProvider kEoB1Npc6StringsDOSGermanProvider = { ARRAYSIZE(kEoB1Npc6StringsDOSGerman), kEoB1Npc6StringsDOSGerman };

static const char *const kEoB1Npc7StringsDOSGerman[3] = {
	"befreien",
	"toeten",
	"Gehen"
};

static const StringListProvider kEoB1Npc7StringsDOSGermanProvider = { ARRAYSIZE(kEoB1Npc7StringsDOSGerman), kEoB1Npc7StringsDOSGerman };

static const char *const kEoB1PryDoorStringsDOSGerman[8] = {
	"Niemand schafft es, die Tuer aufzubrechen.\r",
	"Das Team bricht die Tuer auf.\r",
	"%s bricht die Tuer auf!\r",
	"Das Team versucht die Tuer aufzubrechen, doch es schlaegt fehl.\r",
	"Dieser Gegenstand kann hier nicht plaziert werden.\r",
	"Dieser Gegenstand ist zu gross.\r",
	"Niemand schafft es, die Tuer aufzubrechen.\r",
	"\r"
};

static const StringListProvider kEoB1PryDoorStringsDOSGermanProvider = { ARRAYSIZE(kEoB1PryDoorStringsDOSGerman), kEoB1PryDoorStringsDOSGerman };

static const char *const kEoB1WarningStringsDOSGerman[3] = {
	"Hier geht es nicht weiter.\r",
	"%s kann keine Nahrung zu sich nehmen!\r",
	"Dies kann man nicht essen!\r"
};

static const StringListProvider kEoB1WarningStringsDOSGermanProvider = { ARRAYSIZE(kEoB1WarningStringsDOSGerman), kEoB1WarningStringsDOSGerman };

static const char *const kEoB1ItemSuffixStringsRingsDOSGerman[4] = {
	"Schmuck",
	"Zauber",
	"Nahrungs",
	"Federfall"
};

static const StringListProvider kEoB1ItemSuffixStringsRingsDOSGermanProvider = { ARRAYSIZE(kEoB1ItemSuffixStringsRingsDOSGerman), kEoB1ItemSuffixStringsRingsDOSGerman };

static const char *const kEoB1ItemSuffixStringsPotionsDOSGerman[8] = {
	"Riesenstaerke",
	"Heilungs",
	"Extra Heilungs",
	"Gift",
	"Vitalitaets",
	"Schnelligkeits",
	"Unsichtbarkeits",
	"Gift-Heilungs"
};

static const StringListProvider kEoB1ItemSuffixStringsPotionsDOSGermanProvider = { ARRAYSIZE(kEoB1ItemSuffixStringsPotionsDOSGerman), kEoB1ItemSuffixStringsPotionsDOSGerman };

static const char *const kEoB1ItemSuffixStringsWandsDOSGerman[7] = {
	"Stock",
	"Blitz",
	"Frost",
	"Heilungs",
	"Feuerball",
	"Silvias",
	"Magischer Geschoss"
};

static const StringListProvider kEoB1ItemSuffixStringsWandsDOSGermanProvider = { ARRAYSIZE(kEoB1ItemSuffixStringsWandsDOSGerman), kEoB1ItemSuffixStringsWandsDOSGerman };

static const char *const kEoB1RipItemStringsDOSGerman[3] = {
	"%s verlor ihre ",
	"%s verlor seine ",
	".\r"
};

static const StringListProvider kEoB1RipItemStringsDOSGermanProvider = { ARRAYSIZE(kEoB1RipItemStringsDOSGerman), kEoB1RipItemStringsDOSGerman };

static const char *const kEoB1CursedStringDOSGerman[1] = {
	"Verflucht %s %d"
};

static const StringListProvider kEoB1CursedStringDOSGermanProvider = { ARRAYSIZE(kEoB1CursedStringDOSGerman), kEoB1CursedStringDOSGerman };

static const char *const kEoB1MagicObjectStringsDOSGerman[5] = {
	"Magier-Schriftrolle",
	"Kleriker-Schriftrolle",
	"Ring",
	"Trank",
	"Stab"
};

static const StringListProvider kEoB1MagicObjectStringsDOSGermanProvider = { ARRAYSIZE(kEoB1MagicObjectStringsDOSGerman), kEoB1MagicObjectStringsDOSGerman };

static const char *const kEoB1MagicObjectString5DOSGerman[1] = {
	"Stock"
};

static const StringListProvider kEoB1MagicObjectString5DOSGermanProvider = { ARRAYSIZE(kEoB1MagicObjectString5DOSGerman), kEoB1MagicObjectString5DOSGerman };

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

static const StringListProvider kEoB1PatternSuffixDOSGermanProvider = { ARRAYSIZE(kEoB1PatternSuffixDOSGerman), kEoB1PatternSuffixDOSGerman };

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

static const StringListProvider kEoB1PatternGrFix1DOSGermanProvider = { ARRAYSIZE(kEoB1PatternGrFix1DOSGerman), kEoB1PatternGrFix1DOSGerman };

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

static const StringListProvider kEoB1PatternGrFix2DOSGermanProvider = { ARRAYSIZE(kEoB1PatternGrFix2DOSGerman), kEoB1PatternGrFix2DOSGerman };

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

static const StringListProvider kEoB1ValidateArmorStringDOSGermanProvider = { ARRAYSIZE(kEoB1ValidateArmorStringDOSGerman), kEoB1ValidateArmorStringDOSGerman };

static const char *const kEoB1ValidateNoDropStringDOSGerman[1] = {
	"Das koennt Ihr hier nicht ablegen.\r"
};

static const StringListProvider kEoB1ValidateNoDropStringDOSGermanProvider = { ARRAYSIZE(kEoB1ValidateNoDropStringDOSGerman), kEoB1ValidateNoDropStringDOSGerman };

static const char *const kEoB1PotionStringsDOSGerman[2] = {
	"vergiftet",
	"%s fuehlt sich %s!\r"
};

static const StringListProvider kEoB1PotionStringsDOSGermanProvider = { ARRAYSIZE(kEoB1PotionStringsDOSGerman), kEoB1PotionStringsDOSGerman };

static const char *const kEoB1WandStringsDOSGerman[2] = {
	"Der Stab hat keinen offensichtlichen magischen Effekt.\r",
	"kein effekt.\r"
};

static const StringListProvider kEoB1WandStringsDOSGermanProvider = { ARRAYSIZE(kEoB1WandStringsDOSGerman), kEoB1WandStringsDOSGerman };

static const char *const kEoB1ItemMisuseStringsDOSGerman[3] = {
	" kann dies nicht benutzen.\r",
	"Dies wird automatisch benutzt, wenn angelegt.\r",
	"Dies wird nicht so benutzt.\r"
};

static const StringListProvider kEoB1ItemMisuseStringsDOSGermanProvider = { ARRAYSIZE(kEoB1ItemMisuseStringsDOSGerman), kEoB1ItemMisuseStringsDOSGerman };

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

static const StringListProvider kEoB1TakenStringsDOSGermanProvider = { ARRAYSIZE(kEoB1TakenStringsDOSGerman), kEoB1TakenStringsDOSGerman };

static const char *const kEoB1PotionEffectStringsDOSGerman[8] = {
	"viel staerker",
	"besser",
	"viel besser",
	"einen Moment uebel",
	"nicht laenger hungrig",
	"schnell und agil",
	"transparent",
	"besser"
};

static const StringListProvider kEoB1PotionEffectStringsDOSGermanProvider = { ARRAYSIZE(kEoB1PotionEffectStringsDOSGerman), kEoB1PotionEffectStringsDOSGerman };

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

static const StringListProvider kEoB1YesNoStringsDOSGermanProvider = { ARRAYSIZE(kEoB1YesNoStringsDOSGerman), kEoB1YesNoStringsDOSGerman };

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

static const StringListProvider kEoB1MoreStringsDOSGermanProvider = { ARRAYSIZE(kEoB1MoreStringsDOSGerman), kEoB1MoreStringsDOSGerman };

static const char *const kEoB1NpcMaxStringsDOSGerman[1] = {
	"Es sind nur sechs Charaktere in einem Team erlaubt.  Waehlen Sie aus, welchen Sie entlassen wollen."
};

static const StringListProvider kEoB1NpcMaxStringsDOSGermanProvider = { ARRAYSIZE(kEoB1NpcMaxStringsDOSGerman), kEoB1NpcMaxStringsDOSGerman };

static const char *const kEoB1NpcJoinStringsDOSGerman[1] = {
	"%s wird in's Team aufgenommen.\r"
};

static const StringListProvider kEoB1NpcJoinStringsDOSGermanProvider = { ARRAYSIZE(kEoB1NpcJoinStringsDOSGerman), kEoB1NpcJoinStringsDOSGerman };

static const char *const kEoB1CancelStringsDOSGerman[1] = {
	"ABBRECHEN"
};

static const StringListProvider kEoB1CancelStringsDOSGermanProvider = { ARRAYSIZE(kEoB1CancelStringsDOSGerman), kEoB1CancelStringsDOSGerman };

static const char *const kEoB1MenuStringsMainDOSGerman[8] = {
	"Option Waehlen:",
	"Ausruhen",
	"Zauber lernen",
	"Fuer Zauber beten",
	"Schriftrollen",
	"Einstellungen",
	"Spieloptionen",
	"Ende"
};

static const StringListProvider kEoB1MenuStringsMainDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsMainDOSGerman), kEoB1MenuStringsMainDOSGerman };

static const char *const kEoB1MenuStringsSaveLoadDOSGerman[8] = {
	"Spiel laden",
	"Spiel speichern",
	"Charakter entlassen",
	"Spielende",
	"Spieloptionen:",
	"\r   Gespeichert.",
	"\r Speichern\r Fehler!",
	"\r Spiel laden\r Fehler!"
};

static const StringListProvider kEoB1MenuStringsSaveLoadDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsSaveLoadDOSGerman), kEoB1MenuStringsSaveLoadDOSGerman };

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

static const StringListProvider kEoB1MenuStringsOnOffDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsOnOffDOSGerman), kEoB1MenuStringsOnOffDOSGerman };

static const char *const kEoB1MenuStringsSpellsDOSGerman[17] = {
	"\r\r Charakter aus dem\r Team waehlen, der\r zaubern moechte.\r ",
	"\r Der Paladin ist \r noch zu \r unerfahren.",
	"\r\r Der Magier hat\r kein Zauberbuch!",
	"\r\r\r Charakter aus dem\r Team waehlen, der\r beten moechte.\r ",
	"\r Das Team hat kei-\r nen Kleriker, der\r beten koennte.\r ",
	"\r Das Team hat kei-\r nen Magier, der\r zaubern koennte.",
	" Ein bewusstloser\r oder toter Magier\r kann keine Zauber\r lernen.",
	" Ein bewusstloser\r oder toter Kleriker\r kann nicht fuer Zauber\r beten.",
	"1",
	"2",
	"3",
	"4",
	"5",
	"Loesch",
	"Verfuegbare Zauber:",
	"Ja",
	"Nein"
};

static const StringListProvider kEoB1MenuStringsSpellsDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsSpellsDOSGerman), kEoB1MenuStringsSpellsDOSGerman };

static const char *const kEoB1MenuStringsRestDOSGerman[5] = {
	"\rWerden die Heiler\rdas Team heilen?",
	" Jemand ist noch\r verletzt. Rasten,\r bis geheilt?",
	"Ausruhen.",
	"\r Alle Charaktere\r sind ganz\r ausgeruht.",
	" Das Team muss\r fuer neue Zauber\r rasten."
};

static const StringListProvider kEoB1MenuStringsRestDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsRestDOSGerman), kEoB1MenuStringsRestDOSGerman };

static const char *const kEoB1MenuStringsDropDOSGerman[1] = {
	" Sie muessen min-\r destens vier\r Charaktere be-\r sitzen."
};

static const StringListProvider kEoB1MenuStringsDropDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsDropDOSGerman), kEoB1MenuStringsDropDOSGerman };

static const char *const kEoB1MenuStringsExitDOSGerman[1] = {
	" Wollen Sie wirk-\r lich das Spiel\r beenden?\r"
};

static const StringListProvider kEoB1MenuStringsExitDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsExitDOSGerman), kEoB1MenuStringsExitDOSGerman };

static const char *const kEoB1MenuStringsStarveDOSGerman[1] = {
	" Ihr Team verhungert.\r Soll weiter gerastet\r werden?\r "
};

static const StringListProvider kEoB1MenuStringsStarveDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsStarveDOSGerman), kEoB1MenuStringsStarveDOSGerman };

static const char *const kEoB1MenuStringsScribeDOSGerman[5] = {
	"Schriftrolle(n) waeh-\rlen,die notiert wer-\rden soll(en).",
	"\r\r\r Welcher Magier des\r Teams soll\r Schriftrollen\r notieren?",
	" Es gibt keine\r Schriftrollen zum\r Notieren.",
	" Sie haben keine\r Schriftrolle fuer\r diesen Magier.",
	"\r Keiner Ihrer Magier\r kann Schriftrollen\r notieren."
};

static const StringListProvider kEoB1MenuStringsScribeDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsScribeDOSGerman), kEoB1MenuStringsScribeDOSGerman };

static const char *const kEoB1MenuStringsDrop2DOSGerman[3] = {
	" Waehlen Sie den\r zu entlassenden\r Charakter.",
	" Wollen Sie wirk-\r lich das Spiel\r SPEICHERN?",
	" Wollen Sie wirk-\r lich ein altes\r Spiel LADEN?"
};

static const StringListProvider kEoB1MenuStringsDrop2DOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsDrop2DOSGerman), kEoB1MenuStringsDrop2DOSGerman };

static const char *const kEoB1MenuStringsHeadDOSGerman[3] = {
	"Camp:",
	"Einstellungen:",
	"Spieloptionen:"
};

static const StringListProvider kEoB1MenuStringsHeadDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsHeadDOSGerman), kEoB1MenuStringsHeadDOSGerman };

static const char *const kEoB1MenuStringsPoisonDOSGerman[1] = {
	"Vergiftete Team-\rmitglieder sterben!\rTrotzdem rasten?"
};

static const StringListProvider kEoB1MenuStringsPoisonDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsPoisonDOSGerman), kEoB1MenuStringsPoisonDOSGerman };

static const char *const kEoB1MenuStringsMgcDOSGerman[2] = {
	"%-18s %1d",
	"%d von %d Uebrigen.  "
};

static const StringListProvider kEoB1MenuStringsMgcDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsMgcDOSGerman), kEoB1MenuStringsMgcDOSGerman };

static const char *const kEoB1MenuStringsPrefsDOSGerman[4] = {
	"Musik ist %-3s",
	"Geraeusche sind %-3s",
	"Graphikzeilen %-3s",
	"Maus ist %-3s"
};

static const StringListProvider kEoB1MenuStringsPrefsDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsPrefsDOSGerman), kEoB1MenuStringsPrefsDOSGerman };

static const char *const kEoB1MenuStringsRest2DOSGerman[4] = {
	"%s erhaelt %s.\r",
	"%s lernt %s.\r",
	"%s spricht heilung auf %s.\r",
	"Ruhestunden:  %-4d"
};

static const StringListProvider kEoB1MenuStringsRest2DOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsRest2DOSGerman), kEoB1MenuStringsRest2DOSGerman };

static const char *const kEoB1MenuStringsRest4DOSGerman[1] = {
	"\rRast ist nicht moeglich, Monster sind in der Naehe."
};

static const StringListProvider kEoB1MenuStringsRest4DOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsRest4DOSGerman), kEoB1MenuStringsRest4DOSGerman };

static const char *const kEoB1MenuStringsDefeatDOSGerman[1] = {
	"   Dein ganzes team ist geschlagen.  Die Helfer des boesen koennen ihre Plaene ungehindert erfuellen!   \r"
};

static const StringListProvider kEoB1MenuStringsDefeatDOSGermanProvider = { ARRAYSIZE(kEoB1MenuStringsDefeatDOSGerman), kEoB1MenuStringsDefeatDOSGerman };

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

static const StringListProvider kEoB1MenuYesNoStringsDOSGermanProvider = { ARRAYSIZE(kEoB1MenuYesNoStringsDOSGerman), kEoB1MenuYesNoStringsDOSGerman };

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

static const StringListProvider kEoB1CharGuiStringsHpDOSGermanProvider = { ARRAYSIZE(kEoB1CharGuiStringsHpDOSGerman), kEoB1CharGuiStringsHpDOSGerman };

static const char *const kEoB1CharGuiStringsWp1DOSGerman[2] = {
	"FEHL",
	"HACK"
};

static const StringListProvider kEoB1CharGuiStringsWp1DOSGermanProvider = { ARRAYSIZE(kEoB1CharGuiStringsWp1DOSGerman), kEoB1CharGuiStringsWp1DOSGerman };

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

static const StringListProvider kEoB1CharGuiStringsWrDOSGermanProvider = { ARRAYSIZE(kEoB1CharGuiStringsWrDOSGerman), kEoB1CharGuiStringsWrDOSGerman };

static const char *const kEoB1CharGuiStringsSt1DOSGerman[6] = {
	"Tausche",
	"TOT",
	"BEWUSSTLOS",
	"GIFT (LANGSAM)",
	"VERGIFTED",
	"BETAEUBT"
};

static const StringListProvider kEoB1CharGuiStringsSt1DOSGermanProvider = { ARRAYSIZE(kEoB1CharGuiStringsSt1DOSGerman), kEoB1CharGuiStringsSt1DOSGerman };

static const char *const kEoB1CharGuiStringsInDOSGerman[4] = {
	"CHARAKTER INFO",
	"RUESTUNG",
	"ERF",
	"EBN"
};

static const StringListProvider kEoB1CharGuiStringsInDOSGermanProvider = { ARRAYSIZE(kEoB1CharGuiStringsInDOSGerman), kEoB1CharGuiStringsInDOSGerman };

static const char *const kEoB1CharStatusStrings7DOSGerman[1] = {
	"%s besitzt nun keine Riesen-Staerke mehr.\r"
};

static const StringListProvider kEoB1CharStatusStrings7DOSGermanProvider = { ARRAYSIZE(kEoB1CharStatusStrings7DOSGerman), kEoB1CharStatusStrings7DOSGerman };

static const char *const kEoB1CharStatusStrings81DOSGerman[1] = {
	"%s fuehlt, wie das Gift wirkt!\r"
};

static const StringListProvider kEoB1CharStatusStrings81DOSGermanProvider = { ARRAYSIZE(kEoB1CharStatusStrings81DOSGerman), kEoB1CharStatusStrings81DOSGerman };

static const char *const kEoB1CharStatusStrings9DOSGerman[1] = {
	"%s ist nicht mehr gelaehmt!\r"
};

static const StringListProvider kEoB1CharStatusStrings9DOSGermanProvider = { ARRAYSIZE(kEoB1CharStatusStrings9DOSGerman), kEoB1CharStatusStrings9DOSGerman };

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

static const StringListProvider kEoB1CharStatusStrings131DOSGermanProvider = { ARRAYSIZE(kEoB1CharStatusStrings131DOSGerman), kEoB1CharStatusStrings131DOSGerman };

static const char *const kEoB1LevelGainStringsDOSGerman[1] = {
	"\x06\x01""%s steigt eine erfahrungsstufe auf.""\x06\x0F""\r"
};

static const StringListProvider kEoB1LevelGainStringsDOSGermanProvider = { ARRAYSIZE(kEoB1LevelGainStringsDOSGerman), kEoB1LevelGainStringsDOSGerman };

static const char *const kEoB1BookNumbersDOSGerman[5] = {
	"Erster",
	"Zweiter",
	"Dritter",
	"Vierter",
	"Fuenfter"
};

static const StringListProvider kEoB1BookNumbersDOSGermanProvider = { ARRAYSIZE(kEoB1BookNumbersDOSGerman), kEoB1BookNumbersDOSGerman };

static const char *const kEoB1MageSpellsListDOSGerman[26] = {
	"",
	"Ruestung",
	"Brennende Haende",
	"Magie entdecken",
	"Magisch. Geschoss",
	"Magie lesen",
	"Schild",
	"Schockgriff",
	"Unsichtbarkeit",
	"Klopfen",
	"Ms Saeurepfeil",
	"Stinkende Wolke",
	"Magie bannen",
	"Feuerball",
	"Flammenpfeil",
	"Hast",
	"Person festhalten",
	"Usichtbarkeit 3m",
	"Blitzstrahl",
	"Vampirgriff",
	"Furcht",
	"Eissturm",
	"Steinhaut",
	"Todeswolke",
	"Kaeltekegel",
	"Monster festhalten"
};

static const StringListProvider kEoB1MageSpellsListDOSGermanProvider = { ARRAYSIZE(kEoB1MageSpellsListDOSGerman), kEoB1MageSpellsListDOSGerman };

static const char *const kEoB1ClericSpellsListDOSGerman[25] = {
	"",
	"Segen",
	"L. Wnd. heilen",
	"l. Wnd. verurs.",
	"Magie entdecken",
	"Schutz v. Boesem",
	"Staerkung",
	"Flammenklinge",
	"Person festhalten",
	"Gift verlangsamen",
	"Nahrung erschaffen",
	"Magie bannen",
	"Schutzgewand",
	"Gebet",
	"Laehmung aufheben",
	"Schwere W. heilen",
	"Schwere W. verurs.",
	"Gift neutral.",
	"Schutz v.Boesem 3m",
	"Schutz v. Blitzen",
	"Krit. W. heilen",
	"Krit. W. verurs.",
	"Flammenschlag",
	"Tote erwecken",
	"Haende auflegen"
};

static const StringListProvider kEoB1ClericSpellsListDOSGermanProvider = { ARRAYSIZE(kEoB1ClericSpellsListDOSGerman), kEoB1ClericSpellsListDOSGerman };

static const char *const kEoB1SpellNamesDOSGerman[51] = {
	"",
	"Ruestung",
	"brennende Haende",
	"Magie entdecken",
	"magisches Geschoss",
	"Schild",
	"Schockgriff",
	"Unsichtbarkeit",
	"Ms saeurepfeil",
	"stinkende Wolke",
	"Magie bannen",
	"Feuerball",
	"Flammenpfeil",
	"hast",
	"Person festhalten",
	"Unsichtbarkeit 3m",
	"Blitzstrahl",
	"Vampirgriff",
	"Furcht",
	"Eissturm",
	"Steinhaut",
	"Todeswolke",
	"Kaeltekegel",
	"Monster festhalten",
	"Segen",
	"leichte Wunden heilen",
	"leichte Wunden verursachen",
	"Magie entdecken",
	"Schutz vor boesem",
	"Staerkung",
	"Flammenklinge",
	"Person festhalten",
	"Gift verlangsamen",
	"Nahrung erschaffen",
	"Magie bannen",
	"Schutzgewand",
	"Gebet",
	"Laehmung aufheben",
	"schwere Wunden heilen",
	"schwere Wunden verursachen",
	"Gift neutralisieren",
	"Schutz vor boesem 3m",
	"Schutz vor Blitzen",
	"kritische Wunden heilen",
	"kritische Wunden verursachen",
	"Flammenschlag",
	"Tote erwecken",
	"Haende auflegen",
	"",
	"",
	""
};

static const StringListProvider kEoB1SpellNamesDOSGermanProvider = { ARRAYSIZE(kEoB1SpellNamesDOSGerman), kEoB1SpellNamesDOSGerman };

static const char *const kEoB1MagicStrings1DOSGerman[6] = {
	"KEIN ZAUBER",
	"KEIN ZAUBER",
	"Fuer diesen Zauber musst du eine Hand frei haben.\r",
	"Zwei Sprueche dieses Typs koennen nicht gleichzeitig wirken.\r",
	"%s zaubert %s.\r",
	"ok\r"
};

static const StringListProvider kEoB1MagicStrings1DOSGermanProvider = { ARRAYSIZE(kEoB1MagicStrings1DOSGerman), kEoB1MagicStrings1DOSGerman };

static const char *const kEoB1MagicStrings2DOSGerman[3] = {
	"Kein Effekt\r",
	"%s wurde aufgeloest!\r",
	"Das Team wurde mit einem Todesbann belegt!\r"
};

static const StringListProvider kEoB1MagicStrings2DOSGermanProvider = { ARRAYSIZE(kEoB1MagicStrings2DOSGerman), kEoB1MagicStrings2DOSGerman };

static const char *const kEoB1MagicStrings3DOSGerman[6] = {
	"Zauber auf welchen Charakter anwenden? ",
	"\rok\r",
	"\rZauber abgebrochen.\r",
	"%s's %s Zauber laesst nach.\r",
	"%s traf das Monster nicht.\r",
	"%s kann nur in vorderen Reihen zuschlagen!\r"
};

static const StringListProvider kEoB1MagicStrings3DOSGermanProvider = { ARRAYSIZE(kEoB1MagicStrings3DOSGerman), kEoB1MagicStrings3DOSGerman };

static const char *const kEoB1MagicStrings4DOSGerman[2] = {
	"Kein Effekt.\r",
	"Kein Effekt\r"
};

static const StringListProvider kEoB1MagicStrings4DOSGermanProvider = { ARRAYSIZE(kEoB1MagicStrings4DOSGerman), kEoB1MagicStrings4DOSGerman };

static const char *const kEoB1MagicStrings6DOSGerman[1] = {
	"%s hat bereits eine hochrangige Ruestungsklasse.\r"
};

static const StringListProvider kEoB1MagicStrings6DOSGermanProvider = { ARRAYSIZE(kEoB1MagicStrings6DOSGerman), kEoB1MagicStrings6DOSGerman };

static const char *const kEoB1MagicStrings7DOSGerman[5] = {
	"1.",
	"2.",
	"3.",
	"4.",
	"5."
};

static const StringListProvider kEoB1MagicStrings7DOSGermanProvider = { ARRAYSIZE(kEoB1MagicStrings7DOSGerman), kEoB1MagicStrings7DOSGerman };

static const char *const kEoB1MagicStrings8DOSGerman[3] = {
	"Alle Zauber auf %s wurden abgewehrt.\r",
	"Das Team ist schon gesegnet!\r",
	"Der Heilungszauber versagt!\r"
};

static const StringListProvider kEoB1MagicStrings8DOSGermanProvider = { ARRAYSIZE(kEoB1MagicStrings8DOSGerman), kEoB1MagicStrings8DOSGerman };

static const byte kEoB1ManDefDOSGerman[120] = {
	0x09, 0x0A, 0x01, 0x00, 0x09, 0x04, 0x03, 0x00,
	0x09, 0x06, 0x01, 0x00, 0x09, 0x03, 0x03, 0x00,
	0x09, 0x04, 0x02, 0x00, 0x09, 0x01, 0x02, 0x00,
	0x09, 0x05, 0x01, 0x00, 0x09, 0x09, 0x02, 0x00,
	0x09, 0x01, 0x03, 0x00, 0x23, 0x01, 0x05, 0x00,
	0x23, 0x02, 0x02, 0x00, 0x23, 0x03, 0x06, 0x00,
	0x23, 0x05, 0x01, 0x00, 0x23, 0x06, 0x03, 0x00,
	0x23, 0x07, 0x01, 0x00, 0x1A, 0x02, 0x01, 0x00,
	0x1A, 0x03, 0x02, 0x00, 0x1A, 0x06, 0x01, 0x00,
	0x24, 0x01, 0x03, 0x00, 0x24, 0x03, 0x03, 0x00,
	0x24, 0x03, 0x01, 0x00, 0x02, 0x04, 0x03, 0x00,
	0x02, 0x03, 0x03, 0x00, 0x02, 0x07, 0x02, 0x00,
	0x01, 0x01, 0x01, 0x00, 0x01, 0x05, 0x03, 0x00,
	0x01, 0x04, 0x03, 0x00, 0x0C, 0x02, 0x01, 0x00,
	0x0C, 0x03, 0x03, 0x00, 0x0C, 0x02, 0x04, 0x00
};

static const ByteProvider kEoB1ManDefDOSGermanProvider = { ARRAYSIZE(kEoB1ManDefDOSGerman), kEoB1ManDefDOSGerman };

static const char *const kEoB1ManWordDOSGerman[31] = {
	"dargestellt",
	"nur",
	"attackieren",
	"sie",
	"handwaffen",
	"monster",
	"diese",
	"wird",
	"jedoch",
	"sie",
	"getragene",
	"sobald",
	"klerikale",
	"getragene",
	"sich",
	"elternteile",
	"gesicht",
	"nicht",
	"ihrer",
	"magische",
	"einige",
	"sich",
	"charaktere",
	"gesinnung",
	"versammlung",
	"wachen",
	"des",
	"werden",
	"seinen",
	"greift",
	""
};

static const StringListProvider kEoB1ManWordDOSGermanProvider = { ARRAYSIZE(kEoB1ManWordDOSGerman), kEoB1ManWordDOSGerman };

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

static const StringListProvider kEoB1ManPromptDOSGermanProvider = { ARRAYSIZE(kEoB1ManPromptDOSGerman), kEoB1ManPromptDOSGerman };

static const char *const kEoB1MonsterDistAttStringsDOSGerman[5] = {
	"%s wurde von einem Schwere-Wunden-Zauber getroffen!\r",
	"Das Team wurde von einem psychischen Hirnstoss getroffen!\r",
	"gelaehmt",
	"vergiftet",
	"gelaehmt"
};

static const StringListProvider kEoB1MonsterDistAttStringsDOSGermanProvider = { ARRAYSIZE(kEoB1MonsterDistAttStringsDOSGerman), kEoB1MonsterDistAttStringsDOSGerman };