ImHex/plugins/builtin/source/lang/de_DE.cpp

#include <hex/api/content_registry.hpp>
#include <hex/helpers/lang.hpp>

namespace hex::plugin::builtin {

    void registerLanguageDeDE() {
        ContentRegistry::Language::registerLanguage("German", "de-DE");

        ContentRegistry::Language::addLocalizations("de-DE", {
            /* ImHex default functionality */
                { "hex.menu.feedback", "Feedback hinterlassen" },
                { "hex.menu.debug_build", "Debug build"},

                { "hex.welcome.header.main", "Wilkommen zu ImHex" },
                { "hex.welcome.header.start", "Start" },
                    { "hex.welcome.start.create_file", "Neue Datei Erstellen" },
                    { "hex.welcome.start.open_file", "Datei Öffnen" },
                    { "hex.welcome.start.open_project", "Projekt Öffnen" },
                    { "hex.welcome.start.recent", "Kürzlich geöffnet" },
                    { "hex.welcome.start.open_other", "Andere Provider" },
                { "hex.welcome.header.help", "Hilfe" },
                    { "hex.welcome.help.repo", "GitHub Repository" },
                        { "hex.welcome.help.repo.link", "https://imhex.werwolv.net/git" },
                    { "hex.welcome.help.gethelp", "Hilfe erhalten" },
                        { "hex.welcome.help.gethelp.link", "https://github.com/WerWolv/ImHex/discussions/categories/get-help" },
                    { "hex.welcome.help.discord", "Discord Server" },
                        { "hex.welcome.help.discord.link", "https://imhex.werwolv.net/discord" },
                { "hex.welcome.header.plugins", "Geladene Plugins" },
                    { "hex.welcome.plugins.plugin", "Plugin" },
                    { "hex.welcome.plugins.author", "Autor" },
                    { "hex.welcome.plugins.desc", "Beschreibung" },
                { "hex.welcome.header.customize", "Anpassen" },
                    { "hex.welcome.customize.settings.title", "Einstellungen" },
                    { "hex.welcome.customize.settings.desc", "Ändere ImHex's Einstellungen" },
                { "hex.welcome.header.update", "Updates" },
                    { "hex.welcome.update.title", "Neues Update verfügbar!" },
                    { "hex.welcome.update.desc", "ImHex {0} wurde gerade released! Downloade die neue version hier" },
                    { "hex.welcome.update.link", "https://github.com/WerWolv/ImHex/releases/latest" },
                { "hex.welcome.header.learn", "Lernen" },
                    { "hex.welcome.learn.latest.title", "Neuster Release" },
                    { "hex.welcome.learn.latest.desc", "Lies den momentanen ImHex Changelog" },
                    { "hex.welcome.learn.latest.link", "https://github.com/WerWolv/ImHex/releases/latest" },
                    { "hex.welcome.learn.pattern.title", "Pattern Language Dokumentation" },
                    { "hex.welcome.learn.pattern.desc", "Lern ImHex Patterns zu schreiben mit unserer umfangreichen Dokumentation" },
                    { "hex.welcome.learn.pattern.link", "https://imhex.werwolv.net/docs/pattern_language/pattern_language.html" },
                    { "hex.welcome.learn.plugins.title", "Plugins API" },
                    { "hex.welcome.learn.plugins.desc", "Erweitere ImHex mit neuen Funktionen mit Plugins" },
                    { "hex.welcome.learn.plugins.link", "https://github.com/WerWolv/ImHex/wiki/Plugins-Development-Guide" },
                { "hex.welcome.header.various", "Verschiedenes" },
                { "hex.welcome.tip_of_the_day", "Tipp des Tages" },

                { "hex.safety_backup.title", "Verlorene Daten wiederherstellen" },
                { "hex.safety_backup.desc", "Oh nein, ImHex ist letztes mal abgestürtzt.\nWillst du das verherige Projekt wiederherstellen?"},
                { "hex.safety_backup.restore", "Ja, Wiederherstellen" },
                { "hex.safety_backup.delete", "Nein, Entfernen" },


                { "hex.common.little_endian", "Little Endian" },
                { "hex.common.big_endian", "Big Endian" },
                { "hex.common.decimal", "Dezimal" },
                { "hex.common.hexadecimal", "Hexadezimal" },
                { "hex.common.octal", "Oktal" },
                { "hex.common.info", "Information" },
                { "hex.common.error", "Fehler" },
                { "hex.common.fatal", "Fataler Fehler" },
                { "hex.common.address", "Adresse" },
                { "hex.common.size", "Länge" },
                { "hex.common.region", "Region" },
                { "hex.common.match_selection", "Arbeitsbereich synchronisieren" },
                { "hex.common.yes", "Ja" },
                { "hex.common.no", "Nein" },
                { "hex.common.okay", "Okay" },
                { "hex.common.load", "Laden" },
                { "hex.common.cancel", "Abbrechen" },
                { "hex.common.set", "Setzen" },
                { "hex.common.close", "Schliessen" },
                { "hex.common.dont_show_again", "Nicht mehr anzeigen" },
                { "hex.common.link", "Link" },
                { "hex.common.file", "Datei" },
                { "hex.common.open", "Öffnen" },
                { "hex.common.browse", "Druchsuchen..." },

                { "hex.message.file_handler_failed", "Datei konnte nicht mit registriertem Dateihandler geöffnet werden." },


                /* Builtin plugin features */

                { "hex.builtin.menu.file", "Datei" },
                { "hex.builtin.menu.edit", "Bearbeiten" },
                { "hex.builtin.menu.view", "Ansicht" },
                { "hex.builtin.menu.layout", "Layout" },
                    { "hex.builtin.menu.view.fps", "FPS anzeigen" },
                    { "hex.builtin.menu.view.demo", "ImGui Demo anzeigen" },
                { "hex.builtin.menu.help", "Hilfe" },

                { "hex.builtin.view.bookmarks.name", "Lesezeichen" },
                    { "hex.builtin.view.bookmarks.default_title", "Lesezeichen [0x{0:X} - 0x{1:X}]" },
                    { "hex.builtin.view.bookmarks.no_bookmarks", "Noch kein Lesezeichen erstellt. Füge eines hinzu mit Bearbeiten -> Lesezeichen erstellen" },
                    { "hex.builtin.view.bookmarks.title.info", "Informationen" },
                    { "hex.builtin.view.bookmarks.address", "0x{0:X} : 0x{1:X} ({2} bytes)" },
                    { "hex.builtin.view.bookmarks.button.jump", "Springen" },
                    { "hex.builtin.view.bookmarks.button.remove", "Entfernen" },
                    { "hex.builtin.view.bookmarks.header.name", "Name" },
                    { "hex.builtin.view.bookmarks.header.color", "Farbe" },
                    { "hex.builtin.view.bookmarks.header.comment", "Kommentar" },

                { "hex.builtin.view.command_palette.name", "Befehlspalette" },

                { "hex.builtin.view.data_inspector.name", "Dateninspektor" },
                    { "hex.builtin.view.data_inspector.table.name", "Name" },
                    { "hex.builtin.view.data_inspector.table.value", "Wert" },
                    { "hex.builtin.view.data_inspector.no_data", "Keine bytes angewählt"},

                { "hex.builtin.view.data_processor.name", "Datenprozessor" },
                    { "hex.builtin.view.data_processor.menu.remove_selection", "Auswahl entfernen" },
                    { "hex.builtin.view.data_processor.menu.remove_node", "Knoten entfernen" },
                    { "hex.builtin.view.data_processor.menu.remove_link", "Link entfernen" },
                    { "hex.builtin.view.data_processor.menu.file.load_processor", "Datenprozessor laden..." },
                    { "hex.builtin.view.data_processor.menu.file.save_processor", "Datenprozessor speichern..." },

                { "hex.builtin.view.disassembler.name", "Disassembler" },
                    { "hex.builtin.view.disassembler.position", "Position" },
                    { "hex.builtin.view.disassembler.base", "Basisadresse" },
                    { "hex.builtin.view.disassembler.region", "Code Region" },
                    { "hex.builtin.view.disassembler.settings.header", "Einstellungen" },
                    { "hex.builtin.view.disassembler.arch", "Architektur" },
                        { "hex.builtin.view.disassembler.arm.arm", "ARM Modus" },
                        { "hex.builtin.view.disassembler.arm.thumb", "Thumb Modus" },
                        { "hex.builtin.view.disassembler.arm.default", "Standard Modus" },
                        { "hex.builtin.view.disassembler.arm.cortex_m", "Cortex-M Modus" },
                        { "hex.builtin.view.disassembler.arm.armv8", "ARMv8 Modus" },

                        { "hex.builtin.view.disassembler.mips.mips32", "MIPS32 Modus" },
                        { "hex.builtin.view.disassembler.mips.mips64", "MIPS64 Modus" },
                        { "hex.builtin.view.disassembler.mips.mips32R6", "MIPS32R6 Modus" },
                        { "hex.builtin.view.disassembler.mips.micro", "Micro Modus" },

                        { "hex.builtin.view.disassembler.x86.16bit", "16-bit Modus" },
                        { "hex.builtin.view.disassembler.x86.32bit", "32-bit Modus" },
                        { "hex.builtin.view.disassembler.x86.64bit", "64-bit Modus" },

                        { "hex.builtin.view.disassembler.ppc.32bit", "32-bit Modus" },
                        { "hex.builtin.view.disassembler.ppc.64bit", "64-bit Modus" },

                        { "hex.builtin.view.disassembler.sparc.v9", "Sparc V9 Modus" },

                    { "hex.builtin.view.disassembler.disassemble", "Disassemble" },
                    { "hex.builtin.view.disassembler.disassembling", "Disassemblen..." },
                    { "hex.builtin.view.disassembler.disassembly.title", "Disassembly" },
                        { "hex.builtin.view.disassembler.disassembly.address", "Adresse" },
                        { "hex.builtin.view.disassembler.disassembly.offset", "Offset" },
                        { "hex.builtin.view.disassembler.disassembly.bytes", "Byte" },

                { "hex.builtin.view.hashes.name", "Hashes" },
                    { "hex.builtin.view.hashes.settings", "Einstellungen" },
                    { "hex.builtin.view.hashes.function", "Hash Funktion" },
                    { "hex.builtin.view.hashes.iv", "Startwert" },
                    { "hex.builtin.view.hashes.poly", "Polynomial" },
                    { "hex.builtin.view.hashes.result", "Resultat" },

                { "hex.builtin.view.help.name", "Hilfe" },
                    { "hex.builtin.view.help.about.name", "Über ImHex" },
                        { "hex.builtin.view.help.about.translator", "Von WerWolv übersetzt" },
                        { "hex.builtin.view.help.about.source", "Quellcode auf GitHub verfügbar:" },
                        { "hex.builtin.view.help.about.donations", "Spenden" },
                        { "hex.builtin.view.help.about.thanks", "Wenn dir meine Arbeit gefällt, bitte ziehe eine Spende in Betracht, um das Projekt am Laufen zu halten. Vielen Dank <3" },
                        { "hex.builtin.view.help.about.contributor", "Mitwirkende" },
                        { "hex.builtin.view.help.about.libs", "Benutzte Libraries" },
                        { "hex.builtin.view.help.about.paths", "ImHex Ordner" },
                        { "hex.builtin.view.help.about.license", "Lizenz" },
                    { "hex.builtin.view.help.documentation", "ImHex Dokumentation" },
                    { "hex.builtin.view.help.pattern_cheat_sheet", "Pattern Language Cheat Sheet"},
                    { "hex.builtin.view.help.calc_cheat_sheet", "Rechner Cheat Sheet" },

                { "hex.builtin.view.hexeditor.name", "Hex editor" },
                    { "hex.builtin.view.hexeditor.create_file", "Neu" },
                    { "hex.builtin.view.hexeditor.open_file", "Öffnen" },
                    { "hex.builtin.view.hexeditor.open_project", "Projekt öffnen" },
                    { "hex.builtin.view.hexeditor.save_project", "Projekt speichern" },
                    { "hex.builtin.view.hexeditor.save_data", "Daten speichern" },
                    { "hex.builtin.view.hexeditor.open_base64", "Base64 Datei öffnen" },
                    { "hex.builtin.view.hexeditor.load_enconding_file", "Custom encoding Datei laden" },
                    { "hex.builtin.view.hexeditor.page", "Seite {0} / {1}" },
                    { "hex.builtin.view.hexeditor.save_as", "Speichern unter" },
                    { "hex.builtin.view.hexeditor.exit_application.title", "Applikation verlassen?" },
                    { "hex.builtin.view.hexeditor.exit_application.desc", "Es wurden ungespeicherte Änderungen an diesem Projekt vorgenommen\nBist du sicher, dass du ImHex schliessen willst?" },
                    { "hex.builtin.view.hexeditor.script.title", "Datei mit Loader Skript laden" },
                    { "hex.builtin.view.hexeditor.script.desc", "Lade eine Datei mit Hilfe eines Python Skriptes" },
                    { "hex.builtin.view.hexeditor.script.script", "Skript" },
                        { "hex.builtin.view.hexeditor.script.script.title", "Loader Script: Skript öffnen" },
                    { "hex.builtin.view.hexeditor.script.file", "Datei" },
                    { "hex.builtin.view.hexeditor.script.file.title", "Loader Script: Datei öffnen" },
                    { "hex.builtin.view.hexeditor.processing", "Importieren / Exportieren" },

                    { "hex.builtin.view.hexeditor.menu.file.open_file", "Datei öffnen..." },
                    { "hex.builtin.view.hexeditor.menu.file.open_recent", "Kürzlich geöffnete Dateien" },
                    { "hex.builtin.view.hexeditor.menu.file.clear_recent", "Löschen" },
                    { "hex.builtin.view.hexeditor.menu.file.open_other", "Provider öffnen..." },
                    { "hex.builtin.view.hexeditor.menu.file.save", "Speichern" },
                    { "hex.builtin.view.hexeditor.menu.file.save_as", "Speichern unter..." },
                    { "hex.builtin.view.hexeditor.menu.file.close", "Schliessen" },
                    { "hex.builtin.view.hexeditor.menu.file.quit", "ImHex Beenden" },
                    { "hex.builtin.view.hexeditor.menu.file.open_project", "Projekt öffnen..." },
                    { "hex.builtin.view.hexeditor.menu.file.save_project", "Projekt speichern..." },
                    { "hex.builtin.view.hexeditor.menu.file.load_encoding_file", "Custom encoding laden..." },
                    { "hex.builtin.view.hexeditor.menu.file.import", "Importieren..." },
                        { "hex.builtin.view.hexeditor.menu.file.import.base64", "Base64 Datei" },
                        { "hex.builtin.view.hexeditor.base64.import_error", "Datei ist nicht in einem korrekten Base64 Format!" },
                        { "hex.builtin.view.hexeditor.file_open_error", "Öffnen der Datei fehlgeschlagen!" },
                        { "hex.builtin.view.hexeditor.menu.file.import.ips", "IPS Patch" },
                        { "hex.builtin.view.hexeditor.menu.file.import.ips32", "IPS32 Patch" },
                        { "hex.builtin.view.hexeditor.menu.file.import.script", "Datei mit Loader Script" },

                    { "hex.builtin.view.hexeditor.menu.file.export", "Exportieren..." },
                        { "hex.builtin.view.hexeditor.menu.file.export.title", "Datei exportieren" },
                        { "hex.builtin.view.hexeditor.menu.file.export.ips", "IPS Patch" },
                        { "hex.builtin.view.hexeditor.menu.file.export.ips32", "IPS32 Patch" },
                    { "hex.builtin.view.hexeditor.menu.file.search", "Suchen" },
                        { "hex.builtin.view.hexeditor.search.string", "String" },
                        { "hex.builtin.view.hexeditor.search.hex", "Hex" },
                        { "hex.builtin.view.hexeditor.search.find", "Suchen" },
                        { "hex.builtin.view.hexeditor.search.find_next", "Nächstes" },
                        { "hex.builtin.view.hexeditor.search.find_prev", "Vorheriges" },
                    { "hex.builtin.view.hexeditor.menu.file.goto", "Sprung" },
                        { "hex.builtin.view.hexeditor.goto.offset.absolute", "Absolut" },
                        { "hex.builtin.view.hexeditor.goto.offset.current", "Momentan" },
                        { "hex.builtin.view.hexeditor.goto.offset.begin", "Beginn" },
                        { "hex.builtin.view.hexeditor.goto.offset.end", "Ende" },
                    { "hex.builtin.view.hexeditor.error.read_only", "Schreibzugriff konnte nicht erlangt werden. Datei wurde im Lesemodus geöffnet." },
                    { "hex.builtin.view.hexeditor.error.open", "Öffnen der Datei fehlgeschlagen!" },
                    { "hex.builtin.view.hexeditor.error.create", "Erstellen der neuen Datei fehlgeschlagen!" },
                    { "hex.builtin.view.hexeditor.menu.edit.undo", "Rückgängig" },
                    { "hex.builtin.view.hexeditor.menu.edit.redo", "Wiederholen" },
                    { "hex.builtin.view.hexeditor.menu.edit.copy", "Kopieren" },
                    { "hex.builtin.view.hexeditor.menu.edit.copy_as", "Kopieren als..." },
                        { "hex.builtin.view.hexeditor.copy.hex", "String" },
                        { "hex.builtin.view.hexeditor.copy.c", "C Array" },
                        { "hex.builtin.view.hexeditor.copy.cpp", "C++ Array" },
                        { "hex.builtin.view.hexeditor.copy.csharp", "C# Array" },
                        { "hex.builtin.view.hexeditor.copy.rust", "Rust Array" },
                        { "hex.builtin.view.hexeditor.copy.python", "Python Array" },
                        { "hex.builtin.view.hexeditor.copy.java", "Java Array" },
                        { "hex.builtin.view.hexeditor.copy.js", "JavaScript Array" },
                        { "hex.builtin.view.hexeditor.copy.ascii", "ASCII Art" },
                        { "hex.builtin.view.hexeditor.copy.html", "HTML" },
                    { "hex.builtin.view.hexeditor.menu.edit.paste", "Einfügen" },
                    { "hex.builtin.view.hexeditor.menu.edit.select_all", "Alles auswählen" },
                    { "hex.builtin.view.hexeditor.menu.edit.bookmark", "Lesezeichen erstellen" },
                    { "hex.builtin.view.hexeditor.menu.edit.set_base", "Basisadresse setzen" },
                    { "hex.builtin.view.hexeditor.menu.edit.resize", "Grösse ändern..." },
                    { "hex.builtin.view.hexeditor.menu.edit.insert", "Einsetzen..." },

                { "hex.builtin.view.information.name", "Dateninformationen" },
                    { "hex.builtin.view.information.control", "Einstellungen" },
                    { "hex.builtin.view.information.analyze", "Seite analysieren" },
                    { "hex.builtin.view.information.analyzing", "Analysieren..." },
                    { "hex.builtin.view.information.region", "Analysierte Region" },
                    { "hex.builtin.view.information.magic", "Magic Informationen" },
                    { "hex.builtin.view.information.description", "Beschreibung:" },
                    { "hex.builtin.view.information.mime", "MIME Typ:" },
                    { "hex.builtin.view.information.info_analysis", "Informationsanalysis" },
                    { "hex.builtin.view.information.distribution", "Byte Verteilung" },
                    { "hex.builtin.view.information.entropy", "Entropie" },
                    { "hex.builtin.view.information.block_size", "Blockgrösse" },
                    { "hex.builtin.view.information.block_size.desc", "{0} Blöcke min {1} bytes" },
                    { "hex.builtin.view.information.file_entropy", "Dateientropie" },
                    { "hex.builtin.view.information.highest_entropy", "Höchste Blockentropie" },
                    { "hex.builtin.view.information.encrypted", "Diese Daten sind vermutlich verschlüsselt oder komprimiert!" },
                    { "hex.builtin.view.information.magic_db_added", "Magic Datenbank hinzugefügt!" },

                { "hex.builtin.view.patches.name", "Patches" },
                    { "hex.builtin.view.patches.offset", "Offset" },
                    { "hex.builtin.view.patches.orig", "Originalwert" },
                    { "hex.builtin.view.patches.patch", "Patchwert"},
                    { "hex.builtin.view.patches.remove", "Patch entfernen" },

                { "hex.builtin.view.pattern_editor.name", "Pattern Editor" },
                { "hex.builtin.view.pattern_editor.accept_pattern", "Pattern akzeptieren" },
                    { "hex.builtin.view.pattern_editor.accept_pattern.desc", "Ein oder mehrere kompatible Pattern wurden für diesen Dateityp gefunden" },
                    { "hex.builtin.view.pattern_editor.accept_pattern.pattern_language", "Pattern" },
                    { "hex.builtin.view.pattern_editor.accept_pattern.question", "Ausgewähltes Pattern anwenden?" },
                { "hex.builtin.view.pattern_editor.menu.file.load_pattern", "Pattern laden..." },
                { "hex.builtin.view.pattern_editor.menu.file.save_pattern", "Pattern speichern..." },
                { "hex.builtin.view.pattern_editor.open_pattern", "Pattern öffnen" },
                { "hex.builtin.view.pattern_editor.evaluating", "Evaluieren..." },
                { "hex.builtin.view.pattern_editor.auto", "Auto evaluieren" },
                { "hex.builtin.view.pattern_editor.console", "Konsole" },
                { "hex.builtin.view.pattern_editor.env_vars", "Umgebungsvariablen" },
                { "hex.builtin.view.pattern_editor.settings", "Einstellungen" },
                { "hex.builtin.view.pattern_editor.dangerous_function.name", "Gefährliche funktion erlauben?" },
                { "hex.builtin.view.pattern_editor.dangerous_function.desc", "Dieses Pattern hat versucht eine gefährliche Funktion aufzurufen.\nBist du sicher, dass du diesem Pattern vertraust?" },

                { "hex.builtin.view.pattern_data.name", "Pattern Daten" },
                    { "hex.builtin.view.pattern_data.var_name", "Name" },
                    { "hex.builtin.view.pattern_data.color", "Farbe" },
                    { "hex.builtin.view.pattern_data.offset", "Offset" },
                    { "hex.builtin.view.pattern_data.size", "Grösse" },
                    { "hex.builtin.view.pattern_data.type", "Typ" },
                    { "hex.builtin.view.pattern_data.value", "Wert" },

                { "hex.builtin.view.settings.name", "Einstellungen" },

                { "hex.builtin.view.strings.name", "Strings" },
                    { "hex.builtin.view.strings.copy", "String kopieren" },
                    { "hex.builtin.view.strings.demangle", "Demangle" },
                    { "hex.builtin.view.strings.min_length", "Minimallänge" },
                    { "hex.builtin.view.strings.filter", "Filter" },
                    { "hex.builtin.view.strings.extract", "Extrahieren" },
                    { "hex.builtin.view.strings.regex_error", "Ungültiges Regex" },
                    { "hex.builtin.view.strings.results", "{0} Ergebnisse" },
                    { "hex.builtin.view.strings.searching", "Suchen..." },
                    { "hex.builtin.view.strings.offset", "Offset" },
                    { "hex.builtin.view.strings.size", "Grösse" },
                    { "hex.builtin.view.strings.string", "String" },
                    { "hex.builtin.view.strings.demangle.title", "Demangled Namen" },
                    { "hex.builtin.view.strings.demangle.copy", "Kopieren" },

                { "hex.builtin.view.tools.name", "Werkzeuge" },

                { "hex.builtin.view.yara.name", "Yara Regeln" },
                    { "hex.builtin.view.yara.header.rules", "Regeln" },
                        { "hex.builtin.view.yara.reload", "Neu laden" },
                        { "hex.builtin.view.yara.match", "Regeln anwenden" },
                        { "hex.builtin.view.yara.matching", "Anwenden..." },
                        { "hex.builtin.view.yara.error", "Yara Kompilerfehler: " },
                    { "hex.builtin.view.yara.header.matches", "Funde" },
                        { "hex.builtin.view.yara.matches.identifier", "Kennung" },
                        { "hex.builtin.view.yara.matches.variable", "Variable" },
                        { "hex.builtin.view.yara.whole_data", "Gesammte Daten Übereinstimmung!" },
                        { "hex.builtin.view.yara.no_rules", "Keine Yara Regeln gefunden. Platziere sie in ImHex's 'yara' Ordner" },
                { "hex.builtin.view.yara.rule_added", "Yara Regel hinzugefügt!" },

                { "hex.builtin.view.constants.name", "Konstanten" },
                    { "hex.builtin.view.constants.row.category", "Kategorie" },
                    { "hex.builtin.view.constants.row.name", "Name" },
                    { "hex.builtin.view.constants.row.desc", "Beschreibung" },
                    { "hex.builtin.view.constants.row.value", "Wert" },

                { "hex.builtin.view.store.name", "Content Store" },
                    { "hex.builtin.view.store.desc", "Downloade zusätzlichen Content von ImHex's online Datenbank" },
                    { "hex.builtin.view.store.reload", "Neu laden" },
                    { "hex.builtin.view.store.row.name", "Name" },
                    { "hex.builtin.view.store.row.description", "Beschreibung" },
                    { "hex.builtin.view.store.download", "Download" },
                    { "hex.builtin.view.store.update", "Update" },
                    { "hex.builtin.view.store.remove", "Entfernen" },
                    { "hex.builtin.view.store.tab.patterns", "Patterns" },
                    { "hex.builtin.view.store.tab.libraries", "Libraries" },
                    { "hex.builtin.view.store.tab.magics", "Magic Files" },
                    { "hex.builtin.view.store.tab.constants", "Konstanten" },
                    { "hex.builtin.view.store.tab.encodings", "Encodings" },
                    { "hex.builtin.view.store.tab.yara", "Yara Rules" },
                    { "hex.builtin.view.store.loading", "Store inhalt wird geladen..." },
                    { "hex.builtin.view.store.download_error", "Datei konnte nicht heruntergeladen werden! Zielordner konnte nicht gefunden werden." },

                { "hex.builtin.view.diff.name", "Diffing" },

                { "hex.builtin.view.provider_settings.name", "Provider Einstellungen" },
                    { "hex.builtin.view.provider_settings.load_popup", "Provider öffnen" },

                { "hex.builtin.command.calc.desc", "Rechner" },
                { "hex.builtin.command.cmd.desc", "Command" },
                { "hex.builtin.command.cmd.result", "Command '{0}' ausführen" },
                { "hex.builtin.command.web.desc", "Webseite nachschlagen" },
                { "hex.builtin.command.web.result", "'{0}' nachschlagen" },

                { "hex.builtin.inspector.binary", "Binär (8 bit)" },
                { "hex.builtin.inspector.u8", "uint8_t" },
                { "hex.builtin.inspector.i8", "int8_t" },
                { "hex.builtin.inspector.u16", "uint16_t" },
                { "hex.builtin.inspector.i16", "int16_t" },
                { "hex.builtin.inspector.u32", "uint32_t" },
                { "hex.builtin.inspector.i32", "int32_t" },
                { "hex.builtin.inspector.u64", "uint64_t" },
                { "hex.builtin.inspector.i64", "int64_t" },
                { "hex.builtin.inspector.float16", "half float (16 bit)" },
                { "hex.builtin.inspector.float", "float (32 bit)" },
                { "hex.builtin.inspector.double", "double (64 bit)" },
                { "hex.builtin.inspector.ascii", "ASCII Zeichen" },
                { "hex.builtin.inspector.wide", "Wide Zeichen" },
                { "hex.builtin.inspector.utf8", "UTF-8 code point" },
                { "hex.builtin.inspector.string", "String" },
                { "hex.builtin.inspector.time32", "time32_t" },
                { "hex.builtin.inspector.time64", "time64_t" },
                { "hex.builtin.inspector.time", "time_t" },
                { "hex.builtin.inspector.guid", "GUID" },
                { "hex.builtin.inspector.rgba8", "RGBA8 Farbe" },

                { "hex.builtin.nodes.constants", "Konstanten" },
                    { "hex.builtin.nodes.constants.int", "Integral" },
                        { "hex.builtin.nodes.constants.int.header", "Integral" },
                        { "hex.builtin.nodes.constants.int.output", "" },
                    { "hex.builtin.nodes.constants.float", "Kommazahl" },
                        { "hex.builtin.nodes.constants.float.header", "Kommazahl" },
                        { "hex.builtin.nodes.constants.float.output", "" },
                    { "hex.builtin.nodes.constants.nullptr", "Nullptr" },
                        { "hex.builtin.nodes.constants.nullptr.header", "Nullptr" },
                        { "hex.builtin.nodes.constants.nullptr.output", "" },
                    { "hex.builtin.nodes.constants.buffer", "Buffer" },
                        { "hex.builtin.nodes.constants.buffer.header", "Buffer" },
                        { "hex.builtin.nodes.constants.buffer.size", "Size" },
                        { "hex.builtin.nodes.constants.buffer.output", "" },
                    { "hex.builtin.nodes.constants.string", "String" },
                        { "hex.builtin.nodes.constants.string.header", "String" },
                        { "hex.builtin.nodes.constants.string.output", "" },
                    { "hex.builtin.nodes.constants.rgba8", "RGBA8 Farbe" },
                        { "hex.builtin.nodes.constants.rgba8.header", "RGBA8 Farbe" },
                        { "hex.builtin.nodes.constants.rgba8.output.r", "Rot" },
                        { "hex.builtin.nodes.constants.rgba8.output.g", "Grün" },
                        { "hex.builtin.nodes.constants.rgba8.output.b", "Blau" },
                        { "hex.builtin.nodes.constants.rgba8.output.a", "Alpha" },
                    { "hex.builtin.nodes.constants.comment", "Kommentar" },
                        { "hex.builtin.nodes.constants.comment.header", "Kommentar" },

                { "hex.builtin.nodes.display", "Anzeigen" },
                    { "hex.builtin.nodes.display.int", "Integral" },
                        { "hex.builtin.nodes.display.int.header", "Integral Anzeige" },
                        { "hex.builtin.nodes.display.int.input", "Wert" },
                    { "hex.builtin.nodes.display.float", "Kommazahl" },
                        { "hex.builtin.nodes.display.float.header", "Kommazahl Anzeige" },
                        { "hex.builtin.nodes.display.float.input", "Wert" },

                { "hex.builtin.nodes.data_access", "Datenzugriff" },
                    { "hex.builtin.nodes.data_access.read", "Lesen" },
                        { "hex.builtin.nodes.data_access.read.header", "Lesen" },
                        { "hex.builtin.nodes.data_access.read.address", "Adresse" },
                        { "hex.builtin.nodes.data_access.read.size", "Grösse" },
                        { "hex.builtin.nodes.data_access.read.data", "Daten" },
                    { "hex.builtin.nodes.data_access.write", "Schreiben" },
                        { "hex.builtin.nodes.data_access.write.header", "Schreiben" },
                        { "hex.builtin.nodes.data_access.write.address", "Adresse" },
                        { "hex.builtin.nodes.data_access.write.data", "Daten" },
                    { "hex.builtin.nodes.data_access.size", "Datengrösse"},
                        { "hex.builtin.nodes.data_access.size.header", "Datengrösse"},
                        { "hex.builtin.nodes.data_access.size.size", "Grösse"},

                { "hex.builtin.nodes.casting", "Datenumwandlung" },
                    { "hex.builtin.nodes.casting.int_to_buffer", "Integral zu Buffer" },
                        { "hex.builtin.nodes.casting.int_to_buffer.header", "Integral zu Buffer" },
                        { "hex.builtin.nodes.casting.int_to_buffer.input", "In" },
                        { "hex.builtin.nodes.casting.int_to_buffer.output", "Out" },
                { "hex.builtin.nodes.casting.buffer_to_int", "Buffer zu Integral" },
                        { "hex.builtin.nodes.casting.buffer_to_int.header", "Buffer zu Integral" },
                        { "hex.builtin.nodes.casting.buffer_to_int.input", "In" },
                        { "hex.builtin.nodes.casting.buffer_to_int.output", "Out" },

                { "hex.builtin.nodes.arithmetic", "Arithmetisch" },
                    { "hex.builtin.nodes.arithmetic.add", "Addition" },
                        { "hex.builtin.nodes.arithmetic.add.header", "Plus" },
                        { "hex.builtin.nodes.arithmetic.add.input.a", "Input A" },
                        { "hex.builtin.nodes.arithmetic.add.input.b", "Input B" },
                        { "hex.builtin.nodes.arithmetic.add.output", "Output" },
                    { "hex.builtin.nodes.arithmetic.sub", "Subtraktion" },
                        { "hex.builtin.nodes.arithmetic.sub.header", "Minus" },
                        { "hex.builtin.nodes.arithmetic.sub.input.a", "Input A" },
                        { "hex.builtin.nodes.arithmetic.sub.input.b", "Input B" },
                        { "hex.builtin.nodes.arithmetic.sub.output", "Output" },
                    { "hex.builtin.nodes.arithmetic.mul", "Multiplikation" },
                        { "hex.builtin.nodes.arithmetic.mul.header", "Mal" },
                        { "hex.builtin.nodes.arithmetic.mul.input.a", "Input A" },
                        { "hex.builtin.nodes.arithmetic.mul.input.b", "Input B" },
                        { "hex.builtin.nodes.arithmetic.mul.output", "Output" },
                    { "hex.builtin.nodes.arithmetic.div", "Division" },
                        { "hex.builtin.nodes.arithmetic.div.header", "Durch" },
                        { "hex.builtin.nodes.arithmetic.div.input.a", "Input A" },
                        { "hex.builtin.nodes.arithmetic.div.input.b", "Input B" },
                        { "hex.builtin.nodes.arithmetic.div.output", "Output" },
                    { "hex.builtin.nodes.arithmetic.mod", "Modulus" },
                        { "hex.builtin.nodes.arithmetic.mod.header", "Modulo" },
                        { "hex.builtin.nodes.arithmetic.mod.input.a", "Input A" },
                        { "hex.builtin.nodes.arithmetic.mod.input.b", "Input B" },
                        { "hex.builtin.nodes.arithmetic.mod.output", "Output" },

                { "hex.builtin.nodes.buffer", "Buffer" },
                    { "hex.builtin.nodes.buffer.combine", "Kombinieren" },
                        { "hex.builtin.nodes.buffer.combine.header", "Buffer kombinieren" },
                        { "hex.builtin.nodes.buffer.combine.input.a", "Input A" },
                        { "hex.builtin.nodes.buffer.combine.input.b", "Input B" },
                        { "hex.builtin.nodes.buffer.combine.output", "Output" },
                    { "hex.builtin.nodes.buffer.slice", "Zerschneiden" },
                        { "hex.builtin.nodes.buffer.slice.header", "Buffer zerschneiden" },
                        { "hex.builtin.nodes.buffer.slice.input.buffer", "Input" },
                        { "hex.builtin.nodes.buffer.slice.input.from", "Von" },
                        { "hex.builtin.nodes.buffer.slice.input.to", "Bis" },
                        { "hex.builtin.nodes.buffer.slice.output", "Output" },
                    { "hex.builtin.nodes.buffer.repeat", "Wiederholen" },
                        { "hex.builtin.nodes.buffer.repeat.header", "Buffer wiederholen" },
                        { "hex.builtin.nodes.buffer.repeat.input.buffer", "Input" },
                        { "hex.builtin.nodes.buffer.repeat.input.count", "Anzahl" },
                        { "hex.builtin.nodes.buffer.repeat.output", "Output" },

                { "hex.builtin.nodes.control_flow", "Kontrollfluss" },
                    { "hex.builtin.nodes.control_flow.if", "If" },
                        { "hex.builtin.nodes.control_flow.if.header", "If" },
                        { "hex.builtin.nodes.control_flow.if.condition", "Bedingung" },
                        { "hex.builtin.nodes.control_flow.if.true", "Wahr" },
                        { "hex.builtin.nodes.control_flow.if.false", "Falsch" },
                        { "hex.builtin.nodes.control_flow.if.output", "Output" },
                    { "hex.builtin.nodes.control_flow.equals", "Gleich" },
                        { "hex.builtin.nodes.control_flow.equals.header", "Gleich" },
                        { "hex.builtin.nodes.control_flow.equals.input.a", "Input A" },
                        { "hex.builtin.nodes.control_flow.equals.input.b", "Input B" },
                        { "hex.builtin.nodes.control_flow.equals.output", "Output" },
                    { "hex.builtin.nodes.control_flow.not", "Nicht" },
                        { "hex.builtin.nodes.control_flow.not.header", "Nicht" },
                        { "hex.builtin.nodes.control_flow.not.input", "Input" },
                        { "hex.builtin.nodes.control_flow.not.output", "Output" },
                    { "hex.builtin.nodes.control_flow.gt", "Grösser als" },
                        { "hex.builtin.nodes.control_flow.gt.header", "Grösser als" },
                        { "hex.builtin.nodes.control_flow.gt.input.a", "Input A" },
                        { "hex.builtin.nodes.control_flow.gt.input.b", "Input B" },
                        { "hex.builtin.nodes.control_flow.gt.output", "Output" },
                    { "hex.builtin.nodes.control_flow.lt", "Kleiner als" },
                        { "hex.builtin.nodes.control_flow.lt.header", "Kleiner als" },
                        { "hex.builtin.nodes.control_flow.lt.input.a", "Input A" },
                        { "hex.builtin.nodes.control_flow.lt.input.b", "Input B" },
                        { "hex.builtin.nodes.control_flow.lt.output", "Output" },
                    { "hex.builtin.nodes.control_flow.and", "UND" },
                        { "hex.builtin.nodes.control_flow.and.header", "Bool'sches UND" },
                        { "hex.builtin.nodes.control_flow.and.input.a", "Input A" },
                        { "hex.builtin.nodes.control_flow.and.input.b", "Input B" },
                        { "hex.builtin.nodes.control_flow.and.output", "Output" },
                    { "hex.builtin.nodes.control_flow.or", "ODER" },
                        { "hex.builtin.nodes.control_flow.or.header", "Bool'sches ODER" },
                        { "hex.builtin.nodes.control_flow.or.input.a", "Input A" },
                        { "hex.builtin.nodes.control_flow.or.input.b", "Input B" },
                        { "hex.builtin.nodes.control_flow.or.output", "Output" },

                { "hex.builtin.nodes.bitwise", "Bitweise Operationen" },
                    { "hex.builtin.nodes.bitwise.and", "UND" },
                        { "hex.builtin.nodes.bitwise.and.header", "Bitweise UND" },
                        { "hex.builtin.nodes.bitwise.and.input.a", "Input A" },
                        { "hex.builtin.nodes.bitwise.and.input.b", "Input B" },
                        { "hex.builtin.nodes.bitwise.and.output", "Output" },
                    { "hex.builtin.nodes.bitwise.or", "ODER" },
                        { "hex.builtin.nodes.bitwise.or.header", "Bitweise ODER" },
                        { "hex.builtin.nodes.bitwise.or.input.a", "Input A" },
                        { "hex.builtin.nodes.bitwise.or.input.b", "Input B" },
                        { "hex.builtin.nodes.bitwise.or.output", "Output" },
                    { "hex.builtin.nodes.bitwise.xor", "Exklusiv ODER" },
                        { "hex.builtin.nodes.bitwise.xor.header", "Bitweise Exklusiv ODER" },
                        { "hex.builtin.nodes.bitwise.xor.input.a", "Input A" },
                        { "hex.builtin.nodes.bitwise.xor.input.b", "Input B" },
                        { "hex.builtin.nodes.bitwise.xor.output", "Output" },
                    { "hex.builtin.nodes.bitwise.not", "Nicht" },
                        { "hex.builtin.nodes.bitwise.not.header", "Bitweise Nicht" },
                        { "hex.builtin.nodes.bitwise.not.input", "Input" },
                        { "hex.builtin.nodes.bitwise.not.output", "Output" },

                { "hex.builtin.nodes.decoding", "Dekodieren" },
                    { "hex.builtin.nodes.decoding.base64", "Base64" },
                        { "hex.builtin.nodes.decoding.base64.header", "Base64 Dekodierer" },
                        { "hex.builtin.nodes.decoding.base64.input", "In" },
                        { "hex.builtin.nodes.decoding.base64.output", "Out" },
                    { "hex.builtin.nodes.decoding.hex", "Hexadezimal" },
                        { "hex.builtin.nodes.decoding.hex.header", "Hexadezimal Dekodierer" },
                        { "hex.builtin.nodes.decoding.hex.input", "In" },
                        { "hex.builtin.nodes.decoding.hex.output", "Out" },

                { "hex.builtin.nodes.crypto", "Kryptographie" },
                    { "hex.builtin.nodes.crypto.aes", "AES Dekryptor" },
                        { "hex.builtin.nodes.crypto.aes.header", "AES Dekryptor" },
                        { "hex.builtin.nodes.crypto.aes.key", "Schlüssel" },
                        { "hex.builtin.nodes.crypto.aes.iv", "IV" },
                        { "hex.builtin.nodes.crypto.aes.nonce", "Nonce" },
                        { "hex.builtin.nodes.crypto.aes.input", "Input" },
                        { "hex.builtin.nodes.crypto.aes.output", "Output" },
                        { "hex.builtin.nodes.crypto.aes.mode", "Modus" },
                        { "hex.builtin.nodes.crypto.aes.key_length", "Schlüssellänge" },



                { "hex.builtin.tools.demangler", "Itanium/MSVC demangler" },
                    { "hex.builtin.tools.demangler.mangled", "Mangled Namen" },
                    { "hex.builtin.tools.demangler.demangled", "Demangled Namen" },
                { "hex.builtin.tools.ascii_table", "ASCII Tabelle" },
                    { "hex.builtin.tools.ascii_table.octal", "Oktal anzeigen" },
                { "hex.builtin.tools.regex_replacer", "Regex Ersetzer" },
                    { "hex.builtin.tools.regex_replacer.pattern", "Regex pattern" },
                    { "hex.builtin.tools.regex_replacer.replace", "Ersatz pattern" },
                    { "hex.builtin.tools.regex_replacer.input", "Input" },
                    { "hex.builtin.tools.regex_replacer.output", "Output" },
                { "hex.builtin.tools.color", "Farbwähler" },
                { "hex.builtin.tools.calc", "Rechner" },
                    { "hex.builtin.tools.input", "Input" },
                    { "hex.builtin.tools.format.standard", "Standard" },
                    { "hex.builtin.tools.format.scientific", "Wissenschaftlich" },
                    { "hex.builtin.tools.format.engineering", "Ingenieur" },
                    { "hex.builtin.tools.format.programmer", "Programmierer" },
                    { "hex.builtin.tools.error", "Letzter Fehler: '{0}'" },
                    { "hex.builtin.tools.history", "Geschichte" },
                    { "hex.builtin.tools.name", "Name" },
                    { "hex.builtin.tools.value", "Wert" },
                { "hex.builtin.tools.base_converter", "Basiskonverter" },
                    { "hex.builtin.tools.base_converter.dec", "DEC" },
                    { "hex.builtin.tools.base_converter.hex", "HEX" },
                    { "hex.builtin.tools.base_converter.oct", "OCT" },
                    { "hex.builtin.tools.base_converter.bin", "BIN" },
                { "hex.builtin.tools.permissions", "UNIX Berechtigungsrechner" },
                    { "hex.builtin.tools.permissions.perm_bits", "Berechtigungs bits" },
                    { "hex.builtin.tools.permissions.absolute", "Absolute Notation" },
                    { "hex.builtin.tools.permissions.setuid_error", "User benötigt execute Rechte, damit setuid bit gilt!" },
                    { "hex.builtin.tools.permissions.setgid_error", "Group benötigt execute Rechte, damit setgid bit gilt!" },
                    { "hex.builtin.tools.permissions.sticky_error", "Other benötigt execute Rechte, damit sticky bit gilt!" },
                { "hex.builtin.tools.file_uploader", "File Uploader" },
                    { "hex.builtin.tools.file_uploader.control", "Einstellungen" },
                    { "hex.builtin.tools.file_uploader.upload", "Upload" },
                    { "hex.builtin.tools.file_uploader.done", "Fertig!" },
                    { "hex.builtin.tools.file_uploader.recent", "Letzte Uploads" },
                    { "hex.builtin.tools.file_uploader.tooltip", "Klicken zum Kopieren\nCTRL + Klicken zum öffnen" },
                    { "hex.builtin.tools.file_uploader.invalid_response", "Ungültige Antwort von Anonfiles!" },
                    { "hex.builtin.tools.file_uploader.error", "Dateiupload fehlgeschlagen\n\nError Code: {0}" },
                { "hex.builtin.tools.wiki_explain", "Wikipedia Definition" },
                    { "hex.builtin.tools.wiki_explain.control", "Einstellungen" },
                    { "hex.builtin.tools.wiki_explain.search", "Suchen" },
                    { "hex.builtin.tools.wiki_explain.results", "Resultate" },
                    { "hex.builtin.tools.wiki_explain.invalid_response", "Ungültige Antwort von Wikipedia!" },
                { "hex.builtin.tools.file_tools", "File Tools" },
                    { "hex.builtin.tools.file_tools.shredder", "Schredder" },
                        { "hex.builtin.tools.file_tools.shredder.warning", "Dieses Tool zerstört eine Datei UNWIEDERRUFLICH. Mit Vorsicht verwenden" },
                        { "hex.builtin.tools.file_tools.shredder.input", "Datei zum schreddern" },
                        { "hex.builtin.tools.file_tools.shredder.picker", "Öffne Datei zum schreddern" },
                        { "hex.builtin.tools.file_tools.shredder.fast", "Schneller Modus" },
                        { "hex.builtin.tools.file_tools.shredder.shredding", "Schreddert..." },
                        { "hex.builtin.tools.file_tools.shredder.shred", "Schreddern" },
                        { "hex.builtin.tools.file_tools.shredder.error.open", "Öffnen der ausgewählten Datei fehlgeschlagen" },
                        { "hex.builtin.tools.file_tools.shredder.success", "Datei erfolgreich geschreddert!" },
                    { "hex.builtin.tools.file_tools.splitter", "Splitter" },
                        { "hex.builtin.tools.file_tools.splitter.sizes.5_75_floppy", "5¼\" Floppy disk (1200KiB)" },
                        { "hex.builtin.tools.file_tools.splitter.sizes.3_5_floppy", "3½\" Floppy disk (1400KiB)" },
                        { "hex.builtin.tools.file_tools.splitter.sizes.zip100", "Zip 100 Disk (100MiB)" },
                        { "hex.builtin.tools.file_tools.splitter.sizes.zip200", "Zip 200 Disk (200MiB)" },
                        { "hex.builtin.tools.file_tools.splitter.sizes.cdrom650", "CD-ROM (650MiB)" },
                        { "hex.builtin.tools.file_tools.splitter.sizes.cdrom700", "CD-ROM (700MiB)" },
                        { "hex.builtin.tools.file_tools.splitter.sizes.fat32", "FAT32 (4GiB)" },
                        { "hex.builtin.tools.file_tools.splitter.sizes.custom", "Benutzerdefiniert" },
                        { "hex.builtin.tools.file_tools.splitter.input", "Zu splittende Datei " },
                        { "hex.builtin.tools.file_tools.splitter.picker.input", "Zu splittende Datei öffnen" },
                        { "hex.builtin.tools.file_tools.splitter.output", "Ziel Pfad" },
                        { "hex.builtin.tools.file_tools.splitter.picker.output", "Ziel Pfad setzen" },
                        { "hex.builtin.tools.file_tools.splitter.splitting", "Splittet..." },
                        { "hex.builtin.tools.file_tools.splitter.split", "Splitten" },
                        { "hex.builtin.tools.file_tools.splitter.error.open", "Öffnen der ausgewählten Datei fehlgeschlagen" },
                        { "hex.builtin.tools.file_tools.splitter.error.size", "Datei ist kleiner als Zielgrösse" },
                        { "hex.builtin.tools.file_tools.splitter.error.create", "Erstellen der Teildatei {0} fehlgeschlagen" },
                        { "hex.builtin.tools.file_tools.splitter.success", "Datei erfolgreich gesplittet!" },
                    { "hex.builtin.tools.file_tools.combiner", "Kombinierer" },
                        { "hex.builtin.tools.file_tools.combiner.add", "Hinzufügen..." },
                        { "hex.builtin.tools.file_tools.combiner.add.picker", "Datei hinzufügen" },
                        { "hex.builtin.tools.file_tools.combiner.delete", "Entfernen" },
                        { "hex.builtin.tools.file_tools.combiner.clear", "Alle entfernen" },
                        { "hex.builtin.tools.file_tools.combiner.output", "Zieldatei " },
                        { "hex.builtin.tools.file_tools.combiner.output.picker", "Ziel Pfad setzen" },
                        { "hex.builtin.tools.file_tools.combiner.combining", "Kombiniert..." },
                        { "hex.builtin.tools.file_tools.combiner.combine", "Kombinieren" },
                        { "hex.builtin.tools.file_tools.combiner.error.open_output", "Erstellen der Zieldatei fehlgeschlagen" },
                        { "hex.builtin.tools.file_tools.combiner.open_input", "Öffnen der Inputdatei {0} fehlgeschlagen" },
                        { "hex.builtin.tools.file_tools.combiner.success", "Dateien erfolgreich kombiniert!" },

                { "hex.builtin.setting.imhex", "ImHex" },
                    { "hex.builtin.setting.imhex.recent_files", "Kürzlich geöffnete Dateien" },
                { "hex.builtin.setting.general", "Allgemein" },
                    { "hex.builtin.setting.general.show_tips", "Tipps beim start anzeigen" },
                    { "hex.builtin.setting.general.auto_load_patterns", "Unterstützte Pattern automatisch laden" },
                { "hex.builtin.setting.interface", "Aussehen" },
                    { "hex.builtin.setting.interface.color", "Farbthema" },
                        { "hex.builtin.setting.interface.color.system", "System" },
                        { "hex.builtin.setting.interface.color.dark", "Dunkel" },
                        { "hex.builtin.setting.interface.color.light", "Hell" },
                        { "hex.builtin.setting.interface.color.classic", "Klassisch" },
                    { "hex.builtin.setting.interface.scaling", "Skalierung" },
                        { "hex.builtin.setting.interface.scaling.native", "Nativ" },
                        { "hex.builtin.setting.interface.scaling.x0_5", "x0.5" },
                        { "hex.builtin.setting.interface.scaling.x1_0", "x1.0" },
                        { "hex.builtin.setting.interface.scaling.x1_5", "x1.5" },
                        { "hex.builtin.setting.interface.scaling.x2_0", "x2.0" },
                    { "hex.builtin.setting.interface.language", "Sprache" },
                    { "hex.builtin.setting.interface.fps", "FPS Limite" },
                    { "hex.builtin.setting.interface.fps.unlocked", "Unbegrenzt" },
                    { "hex.builtin.setting.interface.highlight_alpha", "Markierungssichtbarkeit" },
                { "hex.builtin.setting.hex_editor", "Hex Editor" },
                    { "hex.builtin.setting.hex_editor.column_count", "Anzahl Byte Spalten" },
                    { "hex.builtin.setting.hex_editor.hexii", "HexII anstatt Bytes anzeigen" },
                    { "hex.builtin.setting.hex_editor.ascii", "ASCII Spalte anzeigen" },
                    { "hex.builtin.setting.hex_editor.advanced_decoding", "Erweiterte Dekodierungsspalte anzeigen" },
                    { "hex.builtin.setting.hex_editor.grey_zeros", "Nullen ausgrauen" },
                    { "hex.builtin.setting.hex_editor.uppercase_hex", "Hex Zeichen als Grossbuchstaben" },
                    { "hex.builtin.setting.hex_editor.extra_info", "Extra informationen anzeigen" },

                { "hex.builtin.provider.file.path", "Dateipfad" },
                { "hex.builtin.provider.file.size", "Größe" },
                { "hex.builtin.provider.file.creation", "Erstellungszeit" },
                { "hex.builtin.provider.file.access", "Letzte Zugriffszeit" },
                { "hex.builtin.provider.file.modification", "Letzte Modifikationszeit" },

                { "hex.builtin.provider.file", "Datei Provider" },
                { "hex.builtin.provider.gdb", "GDB Server Provider" },
                    { "hex.builtin.provider.gdb.name", "GDB Server <{0}:{1}>" },
                    { "hex.builtin.provider.gdb.server", "Server" },
                    { "hex.builtin.provider.gdb.ip", "IP Adresse" },
                    { "hex.builtin.provider.gdb.port", "Port" },
                { "hex.builtin.provider.disk", "Datenträger Provider" },
                    { "hex.builtin.provider.disk.selected_disk", "Datenträger" },
                    { "hex.builtin.provider.disk.disk_size", "Datenträgergrösse" },
                    { "hex.builtin.provider.disk.sector_size", "Sektorgrösse" },
                    { "hex.builtin.provider.disk.reload", "Neu laden" },

                { "hex.builtin.layouts.default", "Standard" }
        });
    }

}