<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2007 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
 -->

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="1999566976857398962">"Ja"</string>
    <string name="no" msgid="5541738710521607130">"Nein"</string>
    <string name="create" msgid="986997212165228751">"Erstellen"</string>
    <string name="allow" msgid="3763244945363657722">"Zulassen"</string>
    <string name="deny" msgid="7326117222944479942">"Ablehnen"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Aktivieren"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Unbekannt"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Für Informationen tippen"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Nur noch # Schritt und du bist Entwickler.}other{Nur noch # Schritte und du bist Entwickler.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Du bist jetzt Entwickler!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Okay, du bist bereits Entwickler."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Bitte aktiviere die Entwickleroptionen zuerst."</string>
    <string name="header_category_system" msgid="1665516346845259058">"System"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"In Betrieb"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Außer Betrieb"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Funkschnittstelle deaktiviert"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Kein Roaming"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Nicht verbunden"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Verbindung wird hergestellt"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Verbunden"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Angehalten"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Unbekannt"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Vorschau"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Verkleinern"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Vergrößern"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"„Automatisch drehen“ verwenden"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Bei der Gesichtserkennung wird die Kamera auf der Vorderseite verwendet, um die Genauigkeit beim automatischen Drehen zu verbessern. Bilder werden weder gespeichert noch an Google gesendet."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Sichtbar für alle Bluetooth-Geräte in der Nähe (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Sichtbar für alle Bluetooth-Geräte in der Nähe"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Nicht sichtbar für andere Bluetooth-Geräte"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Nur sichtbar für Partnergeräte"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Bluetooth-Geräte"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Gerätename"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Dieses Gerät umbenennen"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Umbenennen"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Geräteverbindung trennen?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Neues Gerät koppeln"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"Bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Rechtes Gerät koppeln"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Linkes Gerät koppeln"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Anderes Ohr koppeln"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Dein linkes Hörgerät ist verbunden.\n\nWenn du dein rechtes Hörgerät koppeln möchtest, muss es eingeschaltet und bereit zum Koppeln sein."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Dein rechtes Hörgerät ist verbunden.\n\nWenn du dein linkes Hörgerät koppeln möchtest, muss es eingeschaltet und bereit zum Koppeln sein."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Rechtes Ohr koppeln"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Linkes Ohr koppeln"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Für alle verfügbaren Hörgeräte"</string>
    <string name="bluetooth_device_controls_title" msgid="1895676556354697234">"Hörgeräteeinstellungen"</string>
    <string name="bluetooth_device_controls_summary" msgid="8115767735418425663">"Verknüpfung, Kompatibilität mit Hörgeräten"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Für dieses Gerät"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Audioausgabe"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Informationen zur Audioausgabe"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Audio an dein Hörgerät oder den Lautsprecher deines Smartphones weiterleiten lassen"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Ähnlich"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Klingeltöne und Wecker"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Audio bei Anrufen"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Medien"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Benachrichtigungen &amp; Systemtöne"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Standardmäßig wird die Audioausgabe durch individuelle Apps bestimmt"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Unbenanntes Bluetooth-Gerät"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Suche läuft"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Kein Bluetooth-Gerät in der Nähe gefunden"</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Anfrage zur Bluetooth-Kopplung"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Kopplungsanfrage"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Für Kopplung mit <xliff:g id="DEVICE_NAME">%1$s</xliff:g> tippen."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth ist deaktiviert"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Tippe, um die Funktion zu aktivieren"</string>
    <string name="device_picker" msgid="2427027896389445414">"Bluetooth-Gerät auswählen"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> fordert die Berechtigung, Bluetooth zu aktivieren"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> fordert die Berechtigung, Bluetooth zu deaktivieren"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Eine App fordert die Berechtigung, Bluetooth zu aktivieren"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Eine App fordert die Berechtigung, Bluetooth zu deaktivieren"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Bluetooth wird aktiviert..."</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Bluetooth wird deaktiviert..."</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Bluetooth-Verbindungsanfrage"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Anforderung für Telefonbuchzugriff"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Anforderung für Nachrichtenzugriff"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Für andere Geräte als „<xliff:g id="DEVICE_NAME">^1</xliff:g>“ sichtbar"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Bluetooth aktivieren, um eine Verbindung mit anderen Geräten herzustellen."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Meine Geräte"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Neues Gerät koppeln"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Bluetooth-A2DP-Hardware-Offload deaktivieren"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Bluetooth LE Audio-Hardwareauslagerung deaktivieren"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Gerät neu starten?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Die Änderung erfordert einen Neustart des Geräts."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Neu starten"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Abbrechen"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Bluetooth LE Audio deaktivieren"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Deaktiviert die Bluetooth LE Audio-Funktion, wenn das Gerät LE Audio-Hardwarefunktionen unterstützt."</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Ein/Aus für LE Audio in Gerätedetails"</string>
    <string name="bluetooth_enable_leaudio_allow_list" msgid="1692999156437357534">"Zulassungsliste für Bluetooth LE-Audio aktivieren"</string>
    <string name="bluetooth_enable_leaudio_allow_list_summary" msgid="725601205276008525">"Aktiviert die Zulassungslistenfunktion für Bluetooth LE-Audio."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Mediengeräte"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Anrufgeräte"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Andere Geräte"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Gespeicherte Geräte"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth wird aktiviert, um das Koppeln zu ermöglichen"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Verbindungs­einstellungen"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Zuletzt verbundene Geräte"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth aktiviert"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Alle anzeigen"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Eingabestift"</string>
    <string name="stylus_default_notes_app" msgid="3896158797687806941">"Standard-Notizen-App"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Textfelder ausfüllen"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Drücken der Taste am Eingabestift ignorieren"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Eingabestift"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Datum &amp; Uhrzeit"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Löschen"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Proxy-Port"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Umgehung des Proxys für"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Standard wiederherstellen"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Fertig"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Proxy-Hostname"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Achtung"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"Ok"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Der eingegebene Hostname ist ungültig."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Die von dir eingegebene Ausschlussliste ist nicht richtig formatiert. Bitte gib eine durch Kommas getrennte Liste ausgeschlossener Domains ein."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Du musst das Feld für den Port ausfüllen."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Das Feld für den Port muss leer sein, wenn das Feld für den Host leer ist."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Der eingegebene Port ist ungültig."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Der HTTP-Proxy wird vom Browser verwendet, eventuell aber nicht von anderen Apps."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"PAC-URL: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Hostnamen (www.google.com) IPv4 pingen:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"HTTP-Client-Test:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Pingtest ausführen"</string>
    <string name="skip_label" msgid="6380034601349015895">"Überspringen"</string>
    <string name="next_label" msgid="1248293387735652187">"Weiter"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Sprachen"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Reihenfolge der bevorzugten Sprachen"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Systemsprache"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Entfernen"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Sprache hinzufügen"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Sprache"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Bevorzugte Sprache"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"App-Sprachen"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Sprache für einzelne Apps festlegen"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"App-Sprache"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Vorgeschlagene Sprachen"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Alle Sprachen"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Systemsprache"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Standardeinstellung des Systems"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Für diese App ist in den Einstellungen keine Sprachauswahl verfügbar."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Die Sprache kann von den in der App verfügbaren Sprachen abweichen. Einige Apps unterstützen diese Einstellung möglicherweise nicht."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Leg die Sprache für einzelne Apps fest."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Dein System, deine Apps und deine Websites verwenden die erste deiner bevorzugten Sprachen, die unterstützt wird."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Unter „App-Sprache“ kannst du für jede App eine Sprache auswählen."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Weitere Informationen zu App-Sprachen"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Systemsprache in %s ändern?"</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Hierdurch werden deine Geräteinstellungen und deine regionalen Einstellungen geändert."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Ändern"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s nicht verfügbar"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Diese Sprache kann nicht als Systemsprache verwendet werden, aber Apps und Websites werden darüber informiert, dass du diese Sprache bevorzugst."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Regionale Einstellungen"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Einstellungen für Einheiten und Zahlen festlegen"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Wenn du Apps deine regionalen Einstellungen mitteilst, können ihre Dienste für dich personalisiert werden."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Apps verwenden regionale Einstellungen, wo immer dies möglich ist."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatur"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Erster Tag der Woche"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Einstellungen für Zahlen"</string>
    <string name="default_string_of_regional_preference" msgid="7662581547334113719">"Standard-App-Einstellungen verwenden"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Celsius (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Fahrenheit (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"Sonntag"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Montag"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Dienstag"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Mittwoch"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Donnerstag"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Freitag"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Samstag"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Wenn eine App keine regionalen Einstellungen unterstützt, werden für sie stattdessen ihre Standard-Spracheinstellungen verwendet."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Weitere Informationen zu Spracheinstellungen."</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Ausgewählte Sprache entfernen?}other{Ausgewählte Sprachen entfernen?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Text wird in einer anderen Sprache angezeigt."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Du kannst nicht alle Sprachen entfernen"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Behalte mindestens eine bevorzugte Sprache"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Als Systemsprache nicht verfügbar"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Nach oben"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Nach unten"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Ganz nach oben"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Ganz nach unten"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Sprache entfernen"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Aktivität auswählen"</string>
    <string name="cancel" msgid="5780102414089664898">"Abbrechen"</string>
    <string name="okay" msgid="4827099303045669054">"OK"</string>
    <string name="forget" msgid="3754013654135912783">"Entfernen"</string>
    <string name="save" msgid="3125033126936493822">"Speichern"</string>
    <string name="done" msgid="7497982645646431310">"Fertig"</string>
    <string name="apply" msgid="7834684883190163536">"Anwenden"</string>
    <string name="share" msgid="8502235338607613795">"Teilen"</string>
    <string name="add" msgid="8335206931421683426">"Hinzufügen"</string>
    <string name="remove" msgid="1028414219245072102">"Entfernen"</string>
    <string name="settings_label" msgid="943294133671632976">"Einstellungen"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Einstellungen"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Einstellungsverknüpfung"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Flugmodus"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Drahtlos &amp; Netzwerke"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Mobile Daten auch bei Roaming nutzen"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Mobile Daten auch bei Roaming nutzen"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Eventuell fallen Roaminggebühren an."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Zeit automatisch einstellen"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Automatisch festlegen"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Wenn diese Einstellung aktiviert ist, wird dein Standort verwendet, um die Zeitzone einzustellen"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Standardformat für die gewählte Spracheinstellung verwenden"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"24-Stunden-Format"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Uhrzeit"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Zeitformat"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Zeitzone"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Zeitzone auswählen"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Datum"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Nach Region suchen"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Region"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Unterschied zur UTC auswählen"</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer_first_sentence" msgid="1326664252091302458">"Verwendet <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. <xliff:g id="SECOND_SENTENCE">%2$s</xliff:g>"</string>
    <string name="zone_info_footer_second_sentence" msgid="6472889173541729110">"<xliff:g id="DST_TIME_TYPE">%1$s</xliff:g> beginnt wieder am <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Verwendet <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Keine Berücksichtigung der Sommerzeit."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Sommerzeit"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Standardzeit"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Nach Region"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Auf UTC-Basis auswählen"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Sperren nach autom. Ausschalten des Displays"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> nach Ablauf des Zeitlimits"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Unmittelbar nach Ablauf des Zeitlimits, außer bei dauerhafter Entsperrung durch <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g>, außer bei dauerhafter Entsperrung durch <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Sperrbildschirm Text hinzufügen"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Kein Text"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Z. B. Peters Android"</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Standort"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Standort verwenden"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Aus"</string>
    <string name="location_settings_summary_location_on" msgid="7029728269719893381">"{count,plural, =1{An: # App hat Zugriff auf den Standort}other{An: # Apps haben Zugriff auf den Standort}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Wird geladen…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Apps mit der Berechtigung zum Zugriff auf Geräte in der Nähe können die relative Position von verbundenen Geräten ermitteln."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Standortzugriff ist für Apps und Dienste deaktiviert. Wenn du eine Notrufnummer wählst oder eine Nachricht an eine solche Nummer schickst, kann dein Standort dennoch an den Notdienst gesendet werden."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="5329024810729665156">"Weitere Informationen zu Standorteinstellungen"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Konten"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Sicherheit"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Verschlüsselung &amp; Anmeldedaten"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Sperrbildschirm"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Anzeige"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Nicht verfügbar"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Sicherheitsstatus"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Displaysperre, „Mein Gerät finden“, App-Sicherheit"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Sicherheit und Datenschutz"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"App-Sicherheit, Gerätesperre, Berechtigungen"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Gesicht hinzugefügt"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Einrichtung erforderlich"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Entsperrung per Gesicht"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Entsperrung per Gesichtserkennung für die Arbeit"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Gesichtsentsperrung einrichten"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Entsperrung per Gesichtserkennung einrichten"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Per Gesichtserkennung authentifizieren"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Starten"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Wenn die Gesichtsentsperrung mit Bedienungshilfen deaktiviert ist, funktionieren manche Einrichtungsschritte möglicherweise nicht richtig mit TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Zurück"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Einrichtung fortsetzen"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Bedienungshilfen-Einrichtung verwenden"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Abbrechen"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Nein danke"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Ich stimme zu"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Mehr"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Per Gesicht entsperren"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Gesichtsentsperrung zulassen"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Per Gesichtserkennung authentifizieren"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Du kannst die Entsperrung per Gesichtserkennung verwenden, um dein Smartphone zu entsperren oder Käufe zu autorisieren.\n\nHinweis: Dieses Gerät kannst du nicht per Gesichtserkennung entsperren. Weitere Informationen erhältst du vom Administrator deiner Organisation."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Verwende die Entsperrung per Gesichtserkennung, um dein Smartphone zu entsperren, Käufe zu autorisieren oder dich in Apps anzumelden"</string>
    <string name="security_settings_face_enroll_introduction_info_title" msgid="7120796118179406944"></string>
    <string name="security_settings_face_enroll_introduction_info_glasses" msgid="2733870453868907471"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_glasses" msgid="6303917184145586880"></string>
    <string name="security_settings_face_enroll_introduction_how_title" msgid="3680193263037835600"></string>
    <string name="security_settings_face_enroll_introduction_control_title" msgid="4536951089583821051"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_title" msgid="5892729331412694759"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Gesicht in den Kreis halten"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Überspringen"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Du hast die maximale Anzahl an Gesichtern hinzugefügt"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Es können keine weiteren Gesichter hinzugefügt werden"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Anmeldung wurde nicht abgeschlossen"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"Ok"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Zeitüberschreitung bei der Anmeldung per Gesichtserkennung. Versuch es noch einmal."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Anmeldung per Gesichtserkennung ist fehlgeschlagen."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Sieht gut aus. Du bist fertig."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Fertig"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Geschwindigkeit der Gesichtsentsperrung verbessern"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Gesichtsentsperrung neu einrichten"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Entsperrung per Gesichtserkennung neu einrichten"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Sicherheit und Leistung verbessern"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Entsperrung per Gesichtserkennung einrichten"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Lösche dein aktuelles Gesichtsmodell, um die Entsperrung per Gesichtserkennung neu einzurichten.\n\nDein Gesichtsmodell wird dauerhaft und sicher gelöscht.\n\nDanach benötigst du zum Entsperren deines Smartphones oder zur Authentifizierung in Apps deine PIN, dein Muster oder dein Passwort."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Lösche dein aktuelles Gesichtsmodell, um die Entsperrung per Gesichtserkennung neu einzurichten.\n\nDein Gesichtsmodell wird dauerhaft und sicher gelöscht.\n\nDanach benötigst du zum Entsperren deines Smartphones oder zur Authentifizierung in Apps deinen Fingerabdruck, deine PIN, dein Muster oder Passwort."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Gesichtsentsperrung für"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Bei Nutzung der Entsperrung per Gesichtserkennung"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Augen müssen geöffnet sein"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Zum Entsperren des Smartphones müssen deine Augen geöffnet sein"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Bestätigung immer erforderlich"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Bei Gesichtsentsperrung in Apps immer Bestätigung anfordern"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Gesichtsmodell löschen"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Entsperrung per Gesicht einrichten"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Gesichtsmodell löschen?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Dein Gesichtsmodell wird dauerhaft und sicher gelöscht.\n\nNach dem Löschen benötigst du deine PIN, dein Muster oder dein Passwort, um dein Smartphone zu entsperren und dich in Apps zu authentifizieren."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Dein Gesichtsmodell wird dauerhaft und sicher gelöscht.\n\nNach dem Löschen benötigst du deine PIN, dein Muster oder dein Passwort, um dein Smartphone zu entsperren."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Verwende die Entsperrung per Gesichtserkennung, um dein Smartphone zu entsperren"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Fingerabdruck"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Fingerabdruck"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Wenn die Entsperrung per Fingerabdruck genutzt wird"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Fingerabdruck-Einstellungen für die Arbeit"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Fingerabdruck hinzufügen"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Fingerabdruck hinzugefügt}other{# Fingerabdrücke hinzugefügt}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Einrichtung erforderlich"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Fingerabdruck einrichten"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Fingerabdruck zulassen"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Fingerabdruck verwenden"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Weitere Informationen zur Entsperrung per Fingerabdruck"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Du hast die Kontrolle"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Du und dein Kind habt die Kontrolle"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Hinweis"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Du kannst deinen Fingerabdruck verwenden, um dein Smartphone zu entsperren oder Käufe zu autorisieren.\n\nHinweis: Dieses Gerät kann nicht mit deinem Fingerabdruck entsperrt werden. Weitere Informationen erhältst du vom Administrator deiner Organisation."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Abbrechen"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Nein danke"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Ich stimme zu"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Fingerabdruck überspringen?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Die Einrichtung des Fingerabdrucks dauert nur wenige Minuten. Wenn du sie jetzt überspringst, kannst du sie später über die Einstellungen nachholen."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Wenn du dieses Symbol siehst, kannst du deinen Fingerabdruck zur Authentifizierung verwenden, beispielsweise zur Anmeldung in Apps oder um Käufe zu autorisieren"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Hinweis"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"So gehts"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Die Funktion „Entsperrung per Fingerabdruck“ erstellt ein eindeutiges Modell deines Fingerabdrucks, mit dem deine Identität bestätigt werden kann. Bei der Einrichtung legst du deinen Finger dazu immer wieder anders auf. Mit diesen Aufnahmen wird dann das Fingerabdruckmodell erstellt."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Die Funktion „Entsperrung per Fingerabdruck“ erstellt ein eindeutiges Modell des Fingerabdrucks deines Kindes, mit dem seine Identität bestätigt werden kann. Bei der Einrichtung legt es seinen Finger dazu immer wieder anders auf. Mit diesen Aufnahmen wird dann das Fingerabdruckmodell erstellt."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Die besten Ergebnisse erzielst du mit einem Displayschutz, der das Zertifikat „Made for Google“ hat. Bei anderen Displayschutzfolien wird dein Fingerabdruck möglicherweise nicht erkannt."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Die besten Ergebnisse erzielst du mit einem Displayschutz, der das Zertifikat „Made for Google“ hat. Bei anderen Displayschutzfolien wird der Fingerabdruck deines Kindes möglicherweise nicht erkannt."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Watch Unlock"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="6583248094453119314">"Wenn du die Entsperrung per Gesichtserkennung und die Entsperrung per Fingerabdruck einrichtest, wirst du auf dem Smartphone nach deinem Fingerabdruck gefragt, wenn du eine Maske trägst oder dich im Dunkeln befindest.\n\nDu kannst dein Gerät mit deiner Smartwatch entsperren, wenn dein Gesicht oder dein Fingerabdruck nicht erkannt werden."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="4312041617237493461">"Du kannst dein Gerät mit deiner Smartwatch entsperren, wenn dein Fingerabdruck nicht erkannt wird."</string>
    <string name="biometric_settings_intro_with_face" msgid="7658123658803417930">"Du kannst dein Gerät mit deiner Smartwatch entsperren, wenn dein Gesicht nicht erkannt wird."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Fingerabdruck oder Smartwatch für Folgendes verwenden"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Gesicht oder Smartwatch für Folgendes verwenden"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Gesicht, Fingerabdruck oder Smartwatch für Folgendes verwenden"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Smartwatch für Folgendes verwenden"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Gesicht oder Smartwatch verwenden"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Fingerabdruck oder Smartwatch verwenden"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Gesicht, Fingerabdruck oder Smartwatch verwenden"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Smartwatch verwenden"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Zuerst Gesichts- oder Fingerabdruckentsperrung einrichten"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Du kannst dein Gerät mit deiner Smartwatch entsperren, wenn dein Gesicht oder dein Fingerabdruck nicht erkannt wird"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Zuerst Entsperrung per Fingerabdruck einrichten"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Du kannst dein Gerät mit deiner Smartwatch entsperren, wenn dein Fingerabdruck nicht erkannt wird"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Zuerst Entsperrung per Gesichtserkennung einrichten"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Du kannst dein Gerät mit deiner Smartwatch entsperren, wenn dein Gesicht nicht erkannt wird"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Einrichten"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Fingerabdruck und <xliff:g id="WATCH">%s</xliff:g> hinzugefügt"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Fingerabdrücke und <xliff:g id="WATCH">%s</xliff:g> hinzugefügt"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Gesicht und <xliff:g id="WATCH">%s</xliff:g> hinzugefügt"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Gesicht, Fingerabdruck und <xliff:g id="WATCH">%s</xliff:g> hinzugefügt"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Gesicht, Fingerabdrücke und <xliff:g id="WATCH">%s</xliff:g> hinzugefügt"</string>
    <string name="security_settings_biometric_preference_title" msgid="298146483579539448">"Entsperrung per Gesichtserkennung &amp; Fingerabdruck"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Entsperrung per Gesichtserkennung &amp; Fingerabdruck für die Arbeit"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Einrichtung erforderlich"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Gesicht und Fingerabdrücke hinzugefügt"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Gesicht und Fingerabdruck hinzugefügt"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Wenn du die Entsperrung per Gesichtserkennung und die Entsperrung per Fingerabdruck einrichtest, fragt dein Smartphone nach deinem Fingerabdruck, falls du eine Maske trägst oder dich im Dunkeln befindest"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Entsperrmöglichkeiten"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Gesicht oder Fingerabdruck für Folgendes verwenden"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Smartphone entsperren"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Deine Identität in Apps bestätigen"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Gesicht verwenden"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Fingerabdruck verwenden"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Gesicht oder Fingerabdruck verwenden"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"OK"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Entsperrung per Gesichtserkennung kann nicht eingerichtet werden"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Splitscreen-Modus verlassen, um die Entsperrung per Gesichtserkennung einzurichten"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Fingerabdruck konnte nicht eingerichtet werden"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Splitscreen verlassen, um die Entsperrung per Fingerabdruck einzurichten"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"Ok"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Displaysperre überspringen?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Trotzdem überspringen"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Zurück"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Überspringen"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Abbrechen"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Sensor berühren"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Leg den Finger auf die Ein-/Aus-Taste, ohne sie zu drücken"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"So richtest du deinen Fingerabdruck ein"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Er befindet sich auf der Rückseite des Smartphones. Am besten den Zeigefinger verwenden."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Der Fingerabdrucksensor befindet sich auf deinem Display. Auf dem nächsten Bildschirm zeichnest du deinen Fingerabdruck auf."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Starten"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Bewege deinen Finger über das Display, um den Sensor zu finden. Halte den Fingerabdrucksensor gedrückt."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Abbildung mit Gerät und Position des Fingerabdrucksensors"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Name"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"Ok"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Noch einmal versuchen"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Löschen"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Sensor berühren"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Lege deinen Finger auf den Sensor und hebe ihn an, wenn du eine Vibration spürst."</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Lege deinen Finger so lange auf den Sensor, bis du eine Vibration spürst"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Halte deinen Finger an den Sensor, ohne die Taste zu drücken, bis du eine Vibration spürst.\n\nBewege deinen Finger jedes Mal nur ein bisschen. Dadurch kann dein Fingerabdruck besser erfasst werden."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Fingerabdrucksensor gedrückt halten"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Anheben und erneut berühren"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Noch mal"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Dem Fingerabdruck-Symbol folgen"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Lege den Finger immer wieder in leicht geänderter Position auf, bis der Abdruck vollständig erfasst ist."</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Leg deinen Finger jedes Mal für längere Zeit auf den Sensor, wenn sich das Fingerabdrucksymbol bewegt. Dadurch kann dein Fingerabdruck besser erfasst werden."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Leg deine Fingerkuppe auf den Sensor"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Leg die linke Seite deines Fingers auf den Sensor"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Leg die rechte Seite deines Fingers auf den Sensor"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Leg deinen Finger mittig auf den Sensor"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Leg deine Fingerkuppe auf den Sensor"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Leg die linke Seite deines Fingers auf den Sensor"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Leg zuletzt die rechte Seite deines Fingers auf den Sensor"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Halte nacheinander beide Seiten der Fingerkuppe auf den Sensor"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Dadurch kann dein Fingerabdruck besser erfasst werden"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Fingerabdruck zu <xliff:g id="PERCENTAGE">%d</xliff:g> %% eingerichtet"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Zu <xliff:g id="PERCENTAGE">%d</xliff:g> %% eingerichtet"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Fingerabdruck zu <xliff:g id="PERCENTAGE">%d</xliff:g> %% eingerichtet"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Fingerabdruck hinzugefügt"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Jederzeit durch Berühren entsperren"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Du kannst dein Gerät auch bei ausgeschaltetem Display per Fingerabdruck entsperren. Das erhöht allerdings die Gefahr eines versehentlichen Entsperrens."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Display, entsperren"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Später"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Hebe den Finger an und lege ihn dann noch mal auf den Sensor"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Halte nacheinander beide Seiten der Fingerkuppe einen Moment lang auf den Sensor"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Fingerabdruck-Einrichtung überspringen?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Du hast festgelegt, dass du unter anderem deinen Fingerabdruck zum Entsperren deines Smartphones verwenden möchtest. Wenn du diesen Schritt jetzt überspringst, musst du die Einrichtung zu einem späteren Zeitpunkt vornehmen. Die Einrichtung dauert nur ca. eine Minute."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Einrichtung für <xliff:g id="OPTIONS">%s</xliff:g> überspringen?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"PIN-Einrichtung überspringen?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Einrichtung für PIN &amp; Gesicht überspringen?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Einrichtung für PIN &amp; Fingerabdruck überspringen?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Einrichtung für PIN, Gesicht &amp; Fingerabdruck überspringen?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Passworteinrichtung überspringen?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Einrichtung für Passwort &amp; Gesicht überspringen?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Einrichtung von Passwort und Fingerabdruck überspringen?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Einrichtung von Passwort, Gesicht &amp; Fingerabdruck überspringen?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Mustereinrichtung überspringen?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Einrichtung für Muster &amp; Gesicht überspringen?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Einrichtung für Muster &amp; Fingerabdruck überspringen?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Einrichtung für Muster, Gesicht &amp; Fingerabdruck überspringen?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Displaysperre einrichten"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Fertig"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Das ist nicht der Sensor"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Sensor auf Rückseite mit Zeigefinger berühren."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Einrichtung lässt sich nicht abschließen"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Du kannst es entweder jetzt noch einmal versuchen oder den Fingerabdruck später in den Einstellungen einrichten."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Du kannst es entweder jetzt noch einmal versuchen oder den Fingerabdruck später einrichten."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Zeitüberschreitung bei Fingerabdruckeinrichtung"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Du kannst den Fingerabdruck später in den Einstellungen einrichten."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Ein Fehler ist aufgetreten. Du kannst den Fingerabdruck später in den Einstellungen einrichten."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Du kannst den Fingerabdruck später einrichten."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Ein Fehler ist aufgetreten. Du kannst den Fingerabdruck später einrichten."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Weiteren hinzufügen"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Weiter"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Die Option „Displaysperre“ ist deaktiviert. Weitere Informationen erhältst du vom Administrator deiner Organisation."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Du kannst deinen Fingerabdruck trotzdem zur Autorisierung von Käufen und zur Autorisierung des Zugriffs auf Apps verwenden."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Hebe den Finger und berühre den Sensor dann noch einmal"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Der Fingerabdrucksensor kann nicht verwendet werden"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Suche einen Reparaturdienstleister auf."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Weitere Sicher­heits­einstellungen"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Sperre des Arbeitsprofils, Verschlüsselung und mehr"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Verschlüsselung, Anmeldedaten und mehr"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"Sicherheit, weitere Sicherheitseinstellungen, weitere Einstellungen, erweiterte Sicherheitseinstellungen"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Weitere Datenschutzeinstellungen"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Mehr Sicherheit und Datenschutz"</string>
    <string name="security_header" msgid="961514795852103424">"Sicherheit"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Datenschutz"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Arbeitsprofil"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Du kannst bis zu <xliff:g id="COUNT">%d</xliff:g> Fingerabdrücke hinzufügen."</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Du hast die maximale Anzahl an Fingerabdrücken hinzugefügt"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Es können keine Fingerabdrücke mehr hinzugefügt werden"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"„<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>“ löschen"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Du kannst deinen Fingerabdruck dann nicht mehr verwenden, um dein Arbeitsprofil zu entsperren, Käufe zu autorisieren oder dich in geschäftlichen Apps anzumelden."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Verschlüsselung"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Verschlüsselt"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Displaysperre einrichten"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Für zusätzliche Sicherheit lässt sich eine PIN, ein Muster oder ein Passwort einrichten."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Displaysperre einrichten"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Displaysperre einrichten"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Für zusätzliche Sicherheit lässt sich eine PIN, ein Muster oder ein Passwort einrichten."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Smartphone schützen"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Fingerabdruck zum Entsperren hinzufügen"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Displaysperre wählen"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Displaysperre auswählen"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Neue Displaysperre wählen"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Sperre für geschäftliche Apps wählen"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Neue Arbeitsprofilsperre wählen"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Alternative Displaysperre einrichten für zusätzliche Sicherheit"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Alternative Methode für die Displaysperre auswählen"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Wenn du deine Displaysperre vergessen hast, kann dein IT-Administrator sie nicht zurücksetzen."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Separate Sperre für geschäftliche Apps einrichten"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Wenn du diese Sperre vergisst, bitte deinen IT-Administrator, sie zurückzusetzen"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Optionen für die Displaysperre"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Optionen für die Displaysperre"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Entsperren mit automatischer Bestätigung"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Der Bildschirm wird automatisch entsperrt, wenn du eine korrekte PIN mit 6 oder mehr Ziffern eingibst. Diese Option ist etwas weniger sicher, als wenn du zum Bestätigen auf „Eingabe“ tippst."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Korrekte PIN automatisch bestätigen"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Die Bestätigung deiner PIN durch Tippen auf „Eingabe“ ist sicherer als die automatische Bestätigung"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Geräte-PIN eingeben, um automatische Bestätigung zu aktivieren"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Geräte-PIN eingeben, um automatische Bestätigung zu deaktivieren"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Dis­play­sper­re"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Sperre des Arbeitsprofils"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Keine"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Wischen"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Muster"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Passwort"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Jetzt nicht"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Aktuelle Displaysperre"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Muster • Fingerabdruck"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN • Fingerabdruck"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Passwort • Fingerabdruck"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Weiter ohne Fingerabdruck"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Muster • Gesichtsentsperrung"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN • Gesichtsentsperrung"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Passwort • Gesichtsentsperrung"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Ohne Entsperrung per Gesichtserkennung fortfahren"</string>
    <string name="biometrics_unlock_set_unlock_pattern" msgid="8084495264354847044">"Muster • Gesicht • Fingerabdruck"</string>
    <string name="biometrics_unlock_set_unlock_pin" msgid="5912980580857825894">"PIN • Gesicht • Fingerabdruck"</string>
    <string name="biometrics_unlock_set_unlock_password" msgid="4612217647465743624">"Passwort • Gesicht • Fingerabdruck"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7785643433551409223">"Ohne Gesicht oder Fingerabdruck fortfahren"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Keine"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Wischen"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Muster"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Passwort"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Displaysperre löschen?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Profilschutz entfernen?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Ein Muster schützt dein Smartphone, falls es verloren geht oder gestohlen wird"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Ein Muster schützt dein Smartphone, falls es verloren geht oder gestohlen wird.<xliff:g id="EMPTY_LINE">

</xliff:g>Dadurch wird auch das Fingerabdruckmodell gelöscht, das auf deinem Gerät gespeichert ist. Du kannst deinen Fingerabdruck dann nicht mehr zur Authentifizierung in Apps verwenden."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Ein Muster schützt dein Smartphone, falls es verloren geht oder gestohlen wird.<xliff:g id="EMPTY_LINE">

</xliff:g>Außerdem wird dein Gesichtsmodell dauerhaft und sicher gelöscht. Du kannst dein Gesicht nicht mehr zur Authentifizierung in Apps verwenden."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Ein Muster schützt dein Smartphone, falls es verloren geht oder gestohlen wird.<xliff:g id="EMPTY_LINE">

</xliff:g>Dadurch wird das Fingerabdruckmodell gelöscht, das auf deinem Gerät gespeichert ist. Außerdem wird dein Gesichtsmodell dauerhaft und sicher gelöscht. Du kannst dein Gesicht oder deinen Fingerabdruck nicht mehr zur Authentifizierung in Apps verwenden."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"Eine PIN schützt dein Smartphone, falls es verloren geht oder gestohlen wird"</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"Eine PIN schützt dein Smartphone, falls es verloren geht oder gestohlen wird.<xliff:g id="EMPTY_LINE">

</xliff:g>Dadurch wird auch das Fingerabdruckmodell gelöscht, das auf deinem Gerät gespeichert ist. Du kannst deinen Fingerabdruck dann nicht mehr zur Authentifizierung in Apps verwenden."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"Eine PIN schützt dein Smartphone, falls es verloren geht oder gestohlen wird.<xliff:g id="EMPTY_LINE">

</xliff:g>Außerdem wird dein Gesichtsmodell dauerhaft und sicher gelöscht. Du kannst dein Gesicht nicht mehr zur Authentifizierung in Apps verwenden."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"Eine PIN schützt dein Smartphone, falls es verloren geht oder gestohlen wird.<xliff:g id="EMPTY_LINE">

</xliff:g>Dadurch wird das Fingerabdruckmodell gelöscht, das auf deinem Gerät gespeichert ist. Außerdem wird dein Gesichtsmodell dauerhaft und sicher gelöscht. Du kannst dein Gesicht oder deinen Fingerabdruck nicht mehr zur Authentifizierung in Apps verwenden."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Ein Passwort schützt dein Smartphone, falls es verloren geht oder gestohlen wird"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Ein Passwort schützt dein Smartphone, falls es verloren geht oder gestohlen wird.<xliff:g id="EMPTY_LINE">

</xliff:g>Dadurch wird auch das Fingerabdruckmodell gelöscht, das auf deinem Gerät gespeichert ist. Du kannst deinen Fingerabdruck dann nicht mehr zur Authentifizierung in Apps verwenden."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Ein Passwort schützt dein Smartphone, falls es verloren geht oder gestohlen wird.<xliff:g id="EMPTY_LINE">

</xliff:g>Außerdem wird dein Gesichtsmodell dauerhaft und sicher gelöscht. Du kannst dein Gesicht nicht mehr zur Authentifizierung in Apps verwenden."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Ein Passwort schützt dein Smartphone, falls es verloren geht oder gestohlen wird.<xliff:g id="EMPTY_LINE">

</xliff:g>Dadurch wird das Fingerabdruckmodell gelöscht, das auf deinem Gerät gespeichert ist. Außerdem wird dein Gesichtsmodell dauerhaft und sicher gelöscht. Du kannst dein Gesicht oder deinen Fingerabdruck nicht mehr zur Authentifizierung in Apps verwenden."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Der Geräteschutz funktioniert ohne deine Displaysperre nicht."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Der Geräteschutz funktioniert ohne deine Displaysperre nicht.<xliff:g id="EMPTY_LINE">

</xliff:g>Dadurch wird auch das Fingerabdruckmodell gelöscht, das auf deinem Gerät gespeichert ist. Du kannst deinen Fingerabdruck dann nicht mehr zur Authentifizierung in Apps verwenden."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Der Geräteschutz funktioniert ohne deine Displaysperre nicht.<xliff:g id="EMPTY_LINE">

</xliff:g>Außerdem wird dein Gesichtsmodell dauerhaft und sicher gelöscht. Du kannst dein Gesicht nicht mehr zur Authentifizierung in Apps verwenden."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Der Geräteschutz funktioniert ohne deine Displaysperre nicht.<xliff:g id="EMPTY_LINE">

</xliff:g>Dadurch wird das Fingerabdruckmodell gelöscht, das auf deinem Gerät gespeichert ist. Außerdem wird dein Gesichtsmodell dauerhaft und sicher gelöscht. Du kannst dein Gesicht oder deinen Fingerabdruck nicht mehr zur Authentifizierung in Apps verwenden."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Löschen"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> empfiehlt, eine starke PIN oder ein starkes Passwort einzugeben – anderenfalls funktioniert die App möglicherweise nicht wie erwartet"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> empfiehlt, eine neue PIN oder ein neues Passwort einzugeben – anderenfalls funktioniert die App möglicherweise nicht wie erwartet"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> empfiehlt, ein neues Muster, eine neue PIN oder ein neues Passwort einzugeben – anderenfalls funktioniert die App möglicherweise nicht wie erwartet"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> empfiehlt eine neue Displaysperre."</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Bitte versuche es noch einmal. Versuch <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> von <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Deine Daten werden gelöscht"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Wenn du beim nächsten Versuch ein falsches Muster eingibst, werden die Daten auf diesem Gerät gelöscht"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Wenn du beim nächsten Versuch eine falsche PIN eingibst, werden die Daten auf diesem Gerät gelöscht"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Wenn du beim nächsten Versuch ein falsches Passwort eingibst, werden die Daten auf diesem Gerät gelöscht"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Wenn du beim nächsten Versuch ein falsches Muster eingibst, wird dieser Nutzer von dem Gerät entfernt"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Wenn du beim nächsten Versuch eine falsche PIN eingibst, wird dieser Nutzer von dem Gerät entfernt"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Wenn du beim nächsten Versuch ein falsches Passwort eingibst, wird dieser Nutzer von dem Gerät entfernt"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Wenn du beim nächsten Versuch ein falsches Muster eingibst, werden dein Arbeitsprofil und die zugehörigen Daten gelöscht"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Wenn du beim nächsten Versuch eine falsche PIN eingibst, werden dein Arbeitsprofil und die zugehörigen Daten gelöscht"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Wenn du beim nächsten Versuch ein falsches Passwort eingibst, werden dein Arbeitsprofil und die zugehörigen Daten gelöscht"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Muss mindestens # Zeichen haben}other{Muss mindestens # Zeichen haben}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Wenn du nur Zahlen verwendest, muss das Passwort mindestens 1 Zahl enthalten}other{Wenn du nur Zahlen verwendest, muss das Passwort mindestens # Zahlen enthalten}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{PIN muss mindestens # Ziffer haben}other{PIN muss mindestens # Ziffern haben}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{Die PIN muss mindestens aus # Ziffer bestehen, aber eine PIN mit {minAutoConfirmLen} Ziffern wird empfohlen, um die Sicherheit zu erhöhen}other{Die PIN muss mindestens aus # Ziffern bestehen, aber eine PIN mit {minAutoConfirmLen} Ziffern wird empfohlen, um die Sicherheit zu erhöhen}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Passwort muss weniger als # Zeichen haben}other{Passwort muss weniger als # Zeichen haben}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{PIN muss weniger als # Ziffer haben}other{PIN muss weniger als # Ziffern haben}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Der Geräteadministrator lässt die Verwendung einer früheren PIN nicht zu"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Es sind keine ungültigen Zeichen zulässig"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Passwort muss mindestens einen Buchstaben enthalten}other{Passwort muss mindestens # Buchstaben enthalten}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Passwort muss mindestens einen Kleinbuchstaben enthalten}other{Passwort muss mindestens # Kleinbuchstaben enthalten}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Passwort muss mindestens einen Großbuchstaben enthalten}other{Passwort muss mindestens # Großbuchstaben enthalten}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Passwort muss mindestens eine Ziffer enthalten}other{Passwort muss mindestens # Ziffern enthalten}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Passwort muss mindestens ein Sonderzeichen enthalten}other{Passwort muss mindestens # Sonderzeichen enthalten}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Passwort muss mindestens ein Zeichen enthalten, das kein Buchstabe ist}other{Passwort muss mindestens # Zeichen enthalten, die keine Buchstaben sind}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Passwort muss mindestens ein Zeichen enthalten, das keine Ziffer ist}other{Passwort muss mindestens # Zeichen enthalten, die keine Ziffern sind}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Der Geräteadministrator lässt die Verwendung eines früheren Passworts nicht zu"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Aufsteigende, absteigende oder wiederholte Ziffernfolgen sind unzulässig"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Bestätigen"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Löschen"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Die Displaysperre wurde bereits geändert. Versuch es mit der neuen Displaysperre noch mal."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Abbrechen"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Weiter"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Apps zur Geräteverwaltung"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Keine aktiven Apps"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aktive App}other{# aktive Apps}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Trust Agents"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Lege zuerst eine Displaysperre fest, damit du die Option verwenden kannst"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Keine"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 aktiver Trust Agent}other{# aktive Trust Agents}}"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"Mit <xliff:g id="DEVICE_NAME">%1$s</xliff:g> koppeln?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="5310869364570266209">"Neues Mitglied zu koordinierten Geräten hinzufügen"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Bluetooth-Kopplungscode"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Gib den Kopplungscode ein und tippe dann auf die Eingabetaste."</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"Die PIN enthält Buchstaben oder Symbole."</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"In der Regel 0000 oder 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Muss aus 16 Ziffern bestehen"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Eventuell musst du diese PIN auch auf dem anderen Gerät eingeben."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Eventuell musst du diesen Zugangscode auch auf dem anderen Gerät eingeben."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Bestätigen, um die Geräte in koordinierter Art und Weise zu koppeln"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Zugriff auf meine Kontakte und meine Anrufliste zulassen"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Keine Verbindung zu <xliff:g id="DEVICE_NAME">%1$s</xliff:g> möglich"</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Verfügbare Geräte"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Verbinden"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Verbindung trennen"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Koppeln und verbinden"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Bei aktiviertem Bluetooth kann dein Gerät mit Bluetooth-Geräten in der Nähe kommunizieren."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Bei aktiviertem Bluetooth kann dein Gerät mit anderen Bluetooth-Geräten in der Nähe kommunizieren.\n\nDamit es optimal funktioniert, können Apps und Dienste immer nach Geräten in der Nähe suchen, auch wenn Bluetooth deaktiviert ist. Dadurch werden beispielsweise standortbasierte Funktionen und Dienste verbessert. Dies lässt sich in den Bluetooth-Sucheinstellungen ändern."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Ändern"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Gerätedetails"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Tastatureinstellungen"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Bluetooth-Adresse des Geräts: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Bluetooth-Adresse des Geräts: \n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Gerät entkoppeln?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Verknüpfung entfernen"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"App-Verknüpfung aufheben?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"Die <xliff:g id="APP_NAME">%1$s</xliff:g> App ist dann nicht mehr mit „<xliff:g id="DEVICE_NAME">%2$s</xliff:g>“ verknüpft"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Experimentell. Verbessert Audioqualität."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Gerät entkoppeln"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"App-Verknüpfung aufheben"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maximale Zahl verbundener Bluetooth-Audiogeräte"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Maximale Zahl verbundener Bluetooth-Audiogeräte auswählen"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"NFC-Stack-Debugging-Log"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"NFC-Stack-Protokollierungsebene erhöhen"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Ausführliches NFC-Debugging-Log"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Zusätzliche gerätespezifische Anbieterprotokolle in Fehlerberichte einschließen, die private Informationen enthalten können"</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Ungefiltertes NFC-NCI-Protokoll"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Detaillierte NFC-Pakete erfassen, die private Informationen enthalten können"</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Gerät neu starten?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Die detaillierte NFC-Protokollierung wird nur zu Entwicklungszwecken verwendet. Dazu gehören auch zusätzliche NFC-Daten in Fehlerberichten, die private Informationen enthalten können. Starte dein Gerät neu, um diese Einstellung zu ändern."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Neu starten"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Streamen"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"spiegeln"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Kabellose Übertragung aktivieren"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Kein Gerät in der Nähe gefunden."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Verbindung wird hergestellt..."</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Verbunden"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"In Verwendung"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Nicht verfügbar"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Optionen für kabellose Übertragung (WiDi)"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Entfernen"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Fertig"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Name"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2,4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_band_6ghz" msgid="8166833829829455339">"6 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Anmelden"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Website öffnen"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Noch <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Läuft am <xliff:g id="EXPIRY_TIME">%1$s</xliff:g> ab"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbit/s"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbit/s"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mbit/s"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> fordert die Berechtigung, das WLAN für dieses Gerät zu aktivieren"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> fordert die Berechtigung, das WLAN für dieses Gerät zu deaktivieren"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Bytecode von debug-fähigen Apps prüfen"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"ART die Überprüfung des Bytecodes für debug-fähige Apps gestatten"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Aktualisierungsrate anzeigen"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Aktuelle Aktualisierungsrate des Displays anzeigen"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Für NFC muss das Gerät entsperrt werden"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Bereit zur Übertragung von App-Inhalten über NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Aus"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Nicht verfügbar, weil NFC deaktiviert ist"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Wenn diese Funktion aktiviert ist, kannst du App-Inhalte auf ein anderes NFC-fähiges Gerät übertragen, indem du die Geräte aneinanderhältst. Du kannst beispielsweise Webseiten, YouTube-Videos und Kontakte übertragen.\n\nHalte die Geräte einfach aneinander, am besten Rückseite an Rückseite, und berühre den Bildschirm. Was übertragen wird, hängt von der App ab."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"WLAN"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"WLAN verwenden"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"WLAN-Einstellungen"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"WLAN auswählen"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"WLAN wird aktiviert…"</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"WLAN wird deaktiviert…"</string>
    <string name="wifi_error" msgid="4903954145386086899">"Fehler"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"Das 5-GHz-Band ist in diesem Land nicht verfügbar."</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"Im Flugmodus"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Über öffentliche Netzwerke informieren"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Benachrichtigen, wenn ein leistungsstarkes öffentliches Netzwerk verfügbar ist"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"WLAN automatisch aktivieren"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Die WLAN-Funktion wird automatisch eingeschaltet, wenn du in den Abdeckungsbereich gespeicherter WLANs kommst und die Signalqualität gut ist."</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Nicht verfügbar, weil die Einstellung \"Standort\" deaktiviert ist. Aktiviere die Einstellung "<annotation id="link">"Standort"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Zertifikate installieren"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Zur Verbesserung der Standortgenauigkeit können Apps und Dienste weiter nach WLANs suchen, auch wenn die WLAN-Funktion deaktiviert ist. Dadurch können beispielsweise standortbasierte Funktionen und Dienste verbessert werden. Dies lässt sich in den <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>Einstellungen für die WLAN-Suche<xliff:g id="LINK_END_1">LINK_END</xliff:g> ändern."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Aktiviere zur Erhöhung der Standortgenauigkeit die WLAN-Suche in den <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>Einstellungen für die WLAN-Suche<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Automatisch zur mobilen Datennutzung wechseln"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Wenn Internetzugriff über WLAN nicht möglich ist, mobile Daten verwenden. Es können Gebühren für die Datennutzung anfallen."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"WLAN hinzufügen"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"WLAN-Einstellungen"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"WLAN wird automatisch wieder aktiviert"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"WLAN wird nicht automatisch wieder aktiviert"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi-Fi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"WLAN aktivieren, um verfügbare Netze abzurufen"</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Netzwerke werden gesucht…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Du verfügst nicht über die Berechtigung zum Ändern des WLAN-Netzwerks."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"WLAN-Suche aktivieren?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Damit die WLAN-Funktion automatisch aktiviert werden kann, muss die Funktion „WLAN-Suche“ aktiviert sein."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Wenn die Funktion „WLAN-Suche“ aktiviert ist, dürfen Apps und Dienste immer nach WLANs suchen, auch wenn die WLAN-Funktion deaktiviert ist. Das hilft z. B. dabei, standortbasierte Funktionen und Dienste zu verbessern."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Aktivieren"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"WLAN-Suche aktiviert"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Erweiterte Optionen"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Drop-down-Liste \"Erweiterte Optionen\""</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"maximieren"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Netzwerkname"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"SSID eingeben"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Sicherheit"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Verborgenes Netzwerk"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Wenn dein Router keine Netzwerk-ID sendet, du aber in Zukunft eine Verbindung herstellen möchtest, dann lege das Netzwerk als verborgen fest.\n\nDies stellt unter Umständen ein Sicherheitsrisiko dar, weil dein Smartphone regelmäßig ein Signal sendet, um das Netzwerk zu finden.\n\nDeine Routereinstellungen ändern sich nicht, wenn du das Netzwerk als verborgen festlegst."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Signalstärke"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Status"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Brutto-Datenrate Upload"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Brutto-Datenrate Download"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Verbindungsgeschwindigkeit"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frequenz"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"IP-Adresse"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Gespeichert über"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Anmeldedaten für <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"EAP-Methode"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Phase-2-Authentifizierung"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"CA-Zertifikat"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Mindestversion von TLS"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Online-Zertifikatstatus"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domain"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Nutzerzertifikat"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identität"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonyme Identität"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Passwort"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Passwort anzeigen"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"2,4-GHz-Band"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"5-GHz-Band bevorzugt"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"IP-Einstellungen"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Datenschutz"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Abo"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Abo ansehen oder ändern"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Zufällig festgelegte MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Gerät hinzufügen"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Wenn du das Gerät zu „<xliff:g id="SSID">%1$s</xliff:g>“ hinzufügen möchtest, scanne den QR-Code unten"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"QR-Code scannen"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Wenn du eine Verbindung zu \"<xliff:g id="SSID">%1$s</xliff:g>\" herstellen möchtest, scanne den QR-Code unten"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Scanne einen QR-Code, um dein Gerät mit dem WLAN zu verbinden"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"WLAN teilen"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Scanne diesen QR-Code mit einem anderen Gerät, um dich mit „<xliff:g id="SSID">%1$s</xliff:g>“ zu verbinden"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Diesen QR-Code scannen, um eine Verbindung mit „<xliff:g id="SSID">%1$s</xliff:g>“ herzustellen"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Versuche es noch einmal. Falls das Problem weiterhin besteht, wende dich an den Hersteller des Geräts"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Fehler"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Prüfe, ob das Gerät angeschlossen, aufgeladen und eingeschaltet ist"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Prüfe, ob das Gerät angeschlossen, aufgeladen und eingeschaltet ist. Falls das Problem weiterhin besteht, wende dich an den Hersteller des Geräts"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Das Hinzufügen von \"<xliff:g id="SSID">%1$s</xliff:g>\" wird von diesem Gerät nicht unterstützt"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Versuche, die Entfernung zwischen dem Gerät und deinem WLAN-Zugangspunkt oder Router zu verringern"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Prüfe das Passwort und versuch es noch einmal"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Wende dich an den Hersteller des Geräts"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Prüfe die Verbindung und versuche es noch einmal"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Netzwerk auswählen"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Wenn du dein Gerät verbinden möchtest, wähle ein Netzwerk"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Dieses Gerät zu \"<xliff:g id="SSID">%1$s</xliff:g>\" hinzufügen?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"WLAN mit Gerät geteilt"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Weiteres Gerät hinzufügen"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Anderes Netzwerk auswählen"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Gerät konnte nicht hinzugefügt werden"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Gerät gefunden"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"WLAN wird für dieses Gerät freigegeben…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Verbindung wird hergestellt…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Hotspot teilen"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Deine Identität bestätigen"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"WLAN-Passwort: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Passwort des Hotspots: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Automatische Verbindung"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Verbindung zulassen, wenn dieses Netzwerk in Reichweite ist"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Gerät hinzufügen"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"QR-Code verwenden, um diesem Netzwerk ein Gerät hinzuzufügen"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR-Code ist kein gültiges Format"</string>
    <string name="retry" msgid="7542103800274026915">"Noch mal versuchen"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Für andere Gerätenutzer freigeben"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(nicht geändert)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Auswählen"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Mehrere Zertifikate hinzugefügt)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Systemzertifikate verwenden"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Nicht bereitstellen"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Bei der ersten Verwendung als vertrauenswürdig einstufen"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Der Netzwerkname ist zu lang."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Angabe einer Domain erforderlich."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Zertifikat erforderlich."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Zur Verbesserung der Standortgenauigkeit und zu anderen Zwecken möchte <xliff:g id="APP_NAME">%1$s</xliff:g> nach WLANs suchen können, auch wenn die WLAN-Funktion deaktiviert ist.\n\nSollen alle Apps nach WLANs suchen können?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Zur Verbesserung der Standortgenauigkeit und zu anderen Zwecken möchte eine unbekannte App nach WLANs suchen können, auch wenn die WLAN-Funktion deaktiviert ist.\n\nSollen alle Apps nach WLANs suchen können?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Zulassen"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Ablehnen"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Dieses Netzwerk hat keinen Internetzugriff. Verbindung beibehalten?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Wegen beschränkter Konnektivität funktionieren Apps und Dienste eventuell nicht. Trotzdem verwenden?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Für dieses Netzwerk nicht mehr fragen"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Keine Internetverbindung über WLAN vorhanden"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Du kannst zum Mobilfunknetz wechseln, wenn die WLAN-Verbindung schlecht ist. Es können Kosten für die Datennutzung anfallen."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Zum Mobilfunknetz wechseln"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Weiterhin WLAN verwenden"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Nicht mehr anzeigen"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Verbinden"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"WLAN ist aktiviert"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Verbunden mit <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Verbindung zu <xliff:g id="NETWORK_NAME">%1$s</xliff:g> wird hergestellt"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Verbinden…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Netzwerkverbindung konnte nicht hergestellt werden."</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Netzwerk außer Reichweite"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Entfernen"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Ändern"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"Netzwerk konnte nicht entfernt werden."</string>
    <string name="wifi_save" msgid="2312643132472226807">"Speichern"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Netzwerk konnte nicht gespeichert werden."</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Abbrechen"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Netzwerk entfernen?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 Netzwerk}other{# Netzwerke}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 Abo}other{# Abos}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 Netzwerk und Abo}other{# Netzwerke und Abos}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"MAC-Adresse des Geräts"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Zufällige MAC-Adresse"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Zufällige MAC-Adresse (zuletzt verwendet)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Netzwerkdetails"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Subnetzmaske"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Typ"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"IPv6-Adressen"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Gespeicherte WLANs"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Abos"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Andere Netzwerke"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Gib eine gültige IP-Adresse ein."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Gib eine gültige Gateway-Adresse ein."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Gib eine gültige DNS-Adresse ein."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Netzwerkpräfix darf maximal 32 Zeichen enthalten."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (sofern nicht von privatem DNS überschrieben)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (sofern nicht von privatem DNS überschrieben)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Gateway"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Länge d. Netzwerkpräfixes"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Nach Geräten suchen"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Suche läuft…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Gerät umbenennen"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Verfügbare Geräte"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Gespeicherte Gruppen"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Verbindung nicht möglich"</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Gerät konnte nicht umbenannt werden."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Verbindung trennen?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Wenn du die Verbindung trennst, wird deine Verbindung mit <xliff:g id="PEER_NAME">%1$s</xliff:g> beendet."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Wenn du die Verbindung trennst, wird deine Verbindung mit <xliff:g id="PEER_NAME">%1$s</xliff:g> und <xliff:g id="PEER_COUNT">%2$s</xliff:g> weiteren Geräten beendet."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Einladung ablehnen?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Möchtest du die Einladung zum Verbinden mit <xliff:g id="PEER_NAME">%1$s</xliff:g> ablehnen?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Diese Gruppe entfernen?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"WLAN-Hotspot"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Internetverbindung und Inhalte werden nicht für andere Geräte freigegeben"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Kein Passwort festgelegt"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Name des Hotspots"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Passwort des Hotspots"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Band für Zugangspunkt"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Hotspot automatisch deaktivieren"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Wenn keine Geräte verbunden sind"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Kompatibilität erweitern"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Hilft anderen Geräten dabei, diesen Hotspot zu finden. Verringert die Verbindungsgeschwindigkeit mit dem Hotspot."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Hilft anderen Geräten dabei, diesen Hotspot zu finden. Erhöht den Akkuverbrauch."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Geschwindigkeit &amp; Kompatibilität"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2,4 GHz / Kompatibel mit den meisten Geräten"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz / Kompatibel mit vielen Geräten"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz / Kompatibel mit wenigen Geräten"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2,4 und 5 GHz / Kompatibel mit den meisten Geräten"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Wähle eine Frequenz für den Hotspot aus. Die Frequenz wirkt sich auf die Verbindungsgeschwindigkeit aus und hat Einfluss darauf, welche Arten von Geräten den Hotspot finden können."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Bevorzugte Frequenz"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Niedrigere Geschwindigkeit. Kompatibel mit den meisten Geräten."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Hohe Geschwindigkeit. Kompatibel mit vielen Geräten."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 und 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Hohe Geschwindigkeit. Dieser Dualband-Hotspot ist mit den meisten Geräten kompatibel."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Höchste Geschwindigkeit. Kompatibel mit wenigen Geräten."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"In deinem Land oder deiner Region nicht verfügbar"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Wenn die bevorzugte Frequenz nicht verfügbar ist, verwendet dein Hotspot möglicherweise eine andere Frequenz. Die Sicherheitseinstellungen für den Hotspot ändern sich unter Umständen, wenn du die Frequenz änderst."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Nicht verfügbar mit 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Die Sicherheitseinstellungen ändern sich unter Umständen, wenn du die Frequenz des Hotspots änderst"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Hotspot wird aktiviert…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Hotspot wird deaktiviert…"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Tethering nicht verfügbar"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Weitere Informationen erhältst du bei deinem Mobilfunkanbieter"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> ist aktiviert"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Dieses Netzwerk speichern?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Wird gespeichert…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Gespeichert"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Speichern nicht möglich. Noch einmal versuchen."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Netzwerke speichern?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"<xliff:g id="NUMBER">%d</xliff:g> Netzwerke werden gespeichert…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Netzwerke gespeichert"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"WLAN-Telefonie"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Anrufoptionen um WLAN-Anrufe erweitern"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"\"WLAN-Telefonie\" aktivieren, um Abdeckung zu erweitern"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Bevorzugte Anrufeinstellung"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Bevorzugte Anrufeinstellung"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Roaming-Präferenz"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Roaming-Präferenz"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"WLAN"</item>
    <item msgid="8622872038388687383">"Mobil"</item>
    <item msgid="3027927219952052398">"Nur WLAN"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"WLAN"</item>
    <item msgid="7566603075659706590">"Mobil"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Mobilfunknetz nutzen, wenn WLAN nicht verfügbar ist"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Bei nicht verfügbarem Mobilfunknetz WLAN verwenden"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Anruf über WLAN. Bei Abbruch der WLAN-Verbindung endet der Anruf."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Wenn die Option „WLAN-Telefonie“ aktiviert ist, kann dein Smartphone abhängig von deiner Einstellung und von der Signalstärke Anrufe über WLANs oder über das Netz deines Mobilfunkanbieters übertragen. Bevor du diese Funktion aktivierst, solltest du dich bei deinem Mobilfunkanbieter nach den hierfür anfallenden Gebühren und anderen Voraussetzungen erkundigen.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="8102786488994263815">"Notfalladresse"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Wird als dein Standort verwendet, wenn du einen Notruf über WLAN tätigst"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Weitere Informationen zu privaten DNS-Funktionen"</annotation></string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"An"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"WLAN-Telefonie aktivieren"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"WLAN-Telefonie verwenden"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Verbindung zu <xliff:g id="SSID">%1$s</xliff:g> getrennt"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Ton und Vibration"</string>
    <string name="account_settings" msgid="255404935489127404">"Konten"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Konten für Arbeitsprofil – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Konten für persönliches Profil"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Konten mit geklonten Profilen"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Arbeitskonto – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Privates Konto – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Suche"</string>
    <string name="display_settings" msgid="7197750639709493852">"Display"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Bildschirm automatisch drehen"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Aus"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"An"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"An – gesichtsbasiert"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Gesichtserkennung"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Weitere Informationen zum automatischen Drehen"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Bildschirmauflösung"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Hohe Auflösung"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Volle Auflösung"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Die volle Auflösung verbraucht mehr Akku. Wenn du die Auflösung änderst, werden einige Apps möglicherweise neu gestartet."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Ausgewählt"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Farben"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Natürlich"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Verstärkt"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Gesättigt"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Adaptiv"</string>
    <string name="brightness" msgid="6216871641021779698">"Helligkeit"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Automatische Helligkeit"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Die Helligkeit des Displays passt sich automatisch an deine Umgebung und deine Aktivitäten an. Mit dem Schieberegler kannst du manuell nachjustieren und die Funktion „Automatische Helligkeit“ merkt sich deine Präferenz."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"An"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Aus"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Weißabgleich des Bildschirms"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="3627278682437562787">"Setzt die Aktualisierungsrate für einige Inhalte automatisch von 60 auf <xliff:g id="ID_1">%1$s</xliff:g> Hz herauf. Erhöht den Akkuverbrauch."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Maximale Aktualisierungsrate erzwingen"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Höchste Aktualisierungsrate für bessere Touchscreen-Reaktion und flüssigere Animationen. Erhöhter Akkuverbrauch."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Aufmerksamkeitserkennung"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Zugriff auf Kamera erforderlich"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Für die Funktion „Aufmerksamkeitserkennung“ ist der Zugriff auf die Kamera erforderlich. Tippe, um Berechtigungen für Dienste zur Gerätepersonalisierung zu verwalten"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Berechtigungen verwalten"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Verhindert, dass der Bildschirm ausgeschaltet wird, wenn du auf ihn schaust"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Die Funktion „Aufmerksamkeitserkennung“ verwendet die Frontkamera, um zu erkennen, ob jemand den Bildschirm ansieht. Es werden dabei keine Bilder gespeichert und auch nie an Google gesendet."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Aufmerksamkeitserkennung aktivieren"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Display aktiviert lassen, solange du es ansiehst"</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Kamera ist gesperrt"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Für die Gesichtserkennung muss die Kamera entsperrt sein"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Für die Funktion „Aufmerksamkeitserkennung“ muss die Kamera entsperrt sein"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Für die Gesichtserkennung ist der Zugriff auf die Kamera erforderlich. Tippen, um Berechtigungen für Dienste zur Gerätepersonalisierung zu verwalten"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Berechtigungen verwalten"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Nachtlicht"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Die Funktion „Nachtlicht“ gibt der Displayanzeige eine gelbe Tönung. Das schont in dunklen Umgebungen die Augen und kann das Einschlafen erleichtern."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Automatische Aktivierung"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Niemals"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Zu benutzerdefinierter Zeit"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Von Sonnenuntergang bis -aufgang"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Beginn"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Ende"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensität"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Wird nie automatisch aktiviert"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Wird automatisch um <xliff:g id="ID_1">%1$s</xliff:g> aktiviert"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Wird automatisch bei Sonnenuntergang aktiviert"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Wird nie automatisch deaktiviert"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Wird automatisch um <xliff:g id="ID_1">%1$s</xliff:g> deaktiviert"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Wird automatisch bei Sonnenaufgang deaktiviert"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Nachtlicht nicht aktiviert"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Zur Bestimmung von Sonnenaufgang und -untergang ist der Gerätestandort erforderlich."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Standorteinstellungen"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Jetzt aktivieren"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Jetzt deaktivieren"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Bis Sonnenaufgang aktivieren"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Bis Sonnenuntergang deaktivieren"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Dunkler Modus"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Automatische Aktivierung"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Niemals"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Von Sonnenuntergang bis -aufgang"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Zu benutzerdefinierter Zeit"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Wird zur Schlafenszeit aktiviert"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Status"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Wird nie automatisch aktiviert"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Wird automatisch bei Sonnenuntergang aktiviert"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Wird automatisch um <xliff:g id="ID_1">%1$s</xliff:g> aktiviert"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Wird automatisch zur Schlafenszeit aktiviert"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Wird nie automatisch deaktiviert"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Wird automatisch bei Sonnenaufgang deaktiviert"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Wird automatisch um <xliff:g id="ID_1">%1$s</xliff:g> deaktiviert"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Wird automatisch nach der Schlafenszeit deaktiviert"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Beim dunklen Design ist der Hintergrund einiger Bildschirme schwarz, damit dein Akku länger hält. Zeitpläne für das dunkle Design werden erst aktiviert, wenn das Display aus ist."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"„Dunkles Design“ wird aktuell gemäß deinem Zeitplan für den Schlafenszeitmodus aktiviert"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Schlafenszeitmodus – Einstellungen"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Display automatisch ausschalten"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"<xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> ohne Aktivität"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Nicht festgelegt"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Hintergrund"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Hintergrund und Stil"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Startseite, Sperrbildschirm"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Hintergrund ändern"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Display personalisieren"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Hintergrund auswählen"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Smartphone personalisieren"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Verschiedene Designs und Hintergründe ausprobieren"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Bildschirmschoner"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"Bildschirmschoner"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Nicht verfügbar, weil der Modus „Schlafenszeit“ aktiviert ist"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Bildschirmschoner verwenden"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Beim Aufladen oder wenn in Dockingstation"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Während des Andockens und Aufladens"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Beim Aufladen"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Wenn in Dockingstation"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nie"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"An / <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Aus"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Zeitpunkt der Aktivierung"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Zum Aktivieren anheben"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Inaktivitätsdisplay"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Bildschirmverhalten"</string>
    <string name="doze_title" msgid="1523090408230862316">"Display bei Benachrichtigungen aktivieren"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Wenn das Display inaktiv ist, wird es bei neuen Benachrichtigungen aktiviert"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Zeit und Informationen immer anzeigen"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Erhöhter Akkuverbrauch"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Fettdruck"</string>
    <string name="title_font_size" msgid="570613010306330622">"Schriftgröße"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Text vergrößern oder verkleinern"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"SIM-Lock-Einstellungen"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"SIM-Lock"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"SIM sperren"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"PIN für SIM-Karte ändern"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"PIN für SIM-Karte"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"SIM sperren"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"SIM entsperren"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Alte PIN der SIM-Karte"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Neue PIN für SIM-Karte"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Neue PIN erneut eingeben"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"PIN für SIM-Karte"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Gib eine 4- bis 8-stellige PIN ein"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Die PINs stimmen nicht überein"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"SIM-PIN erfolgreich geändert"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"PIN kann nicht deaktiviert werden."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"PIN kann nicht aktiviert werden."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"Ok"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Abbrechen"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"<xliff:g id="CARRIER">%1$s</xliff:g> für mobile Daten nutzen?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Du verwendest <xliff:g id="CARRIER2_0">%2$s</xliff:g> für mobile Daten. Wenn du zu <xliff:g id="CARRIER1">%1$s</xliff:g> wechselst, wird <xliff:g id="CARRIER2_1">%2$s</xliff:g> nicht mehr für mobile Daten verwendet."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"<xliff:g id="CARRIER">%1$s</xliff:g> verwenden"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Bevorzugte SIM aktualisieren?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> ist die einzige SIM-Karte in deinem Gerät. Möchtest du diese SIM-Karte für mobile Daten, Anrufe und SMS verwenden?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Bessere Mobile-Daten-Abdeckung"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Du kannst zulassen, dass dein Gerät für mobile Daten automatisch zu <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> wechselt, wenn du damit einen besseren Empfang hast."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Eventuell sind Anrufe, Nachrichten und Netzwerkverkehr für deine Organisation sichtbar."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Falscher PIN-Code der SIM-Karte. Bitte wende dich an deinen Mobilfunkanbieter, damit er dein Gerät entsperrt."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Falscher PIN-Code für die SIM-Karte. Du hast noch # Versuch, bevor das Gerät nur noch vom Mobilfunkanbieter entsperrt werden kann.}other{Falscher PIN-Code für die SIM-Karte. Du hast noch # Versuche.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Falscher PIN-Code der SIM-Karte. Du hast noch einen Versuch, bevor du das Gerät von deinem Mobilfunkanbieter entsperren lassen musst."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Fehler beim Entsperren mit der PIN der SIM-Karte"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Systemupdates"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Android-Version"</string>
    <string name="security_patch" msgid="4071756145347865382">"Android-Sicherheitsupdate"</string>
    <string name="model_info" msgid="8997566254717810904">"Modell"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Hardwareversion"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Herstellungsjahr"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"Geräte-ID"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Baseband-Version"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Kernel-Version"</string>
    <string name="build_number" msgid="9009733242117579826">"Build-Nummer"</string>
    <string name="module_version" msgid="1787518340082046658">"Google Play-Systemupdate"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Nicht verfügbar"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Speicher"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Speicher und Cache"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Speichereinstellungen"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (SIM-Steckplatz <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (SIM-Steckplatz <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (SIM-Steckplatz <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (Primär)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Zum Ansehen gespeichertes Netzwerk auswählen"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"PRL-Version"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (SIM-Steckplatz <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (SIM-Steckplatz <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (Primär)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"An"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Aus"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Typ des Mobilfunknetzes für Daten"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Typ des Mobilfunknetzes für Anrufe"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Details zum Mobilfunkanbieter"</string>
    <string name="status_data_state" msgid="525196229491743487">"Status des Mobilfunknetzes"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Servicestatus"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Signalstärke"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Mobilfunknetz"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"WLAN-MAC-Adresse"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"WLAN-MAC-Adresse des Geräts"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Bluetooth-Adresse"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Seriennummer"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Betriebszeit"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Wird berechnet..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Umbenennen"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Bereitstellen"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Auswerfen"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"SD-Karte als mobilen Speicher formatieren"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Karte formatieren"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Als mobil formatieren"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formatieren"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Daten migrieren"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Entfernen"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Einrichten"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Speicherplatz freigeben"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Speicher verwalten"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Speicherplatz freigeben"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Mit der Files App kannst du Speicherplatz verwalten und freigeben"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Andere Nutzer"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_mount_success" msgid="393972242641313135">"<xliff:g id="NAME">%1$s</xliff:g> wurde bereitgestellt."</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"<xliff:g id="NAME">%1$s</xliff:g> konnte nicht bereitgestellt werden."</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> wurde sicher ausgeworfen."</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"<xliff:g id="NAME">%1$s</xliff:g> konnte nicht sicher ausgeworfen werden."</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Speicher umbenennen"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"<xliff:g id="NAME_0">^1</xliff:g> ist beschädigt. \n\n<xliff:g id="NAME_1">^1</xliff:g> muss zur Verwendung zuerst eingerichtet werden."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Du kannst diese SD-Karte formatieren, um Fotos, Videos, Musik und mehr darauf zu speichern und auf anderen Geräten auf diese Inhalte zuzugreifen. \n\n"<b>"Dabei werden alle Daten auf dieser SD-Karte gelöscht."</b>" \n\n"<b>"Vor dem Formatieren"</b>" \n\n"<b>"Sichere deine Fotos und anderen Medien"</b>" \nVerschiebe deine Mediendateien auf diesem Gerät in einen alternativen Speicher oder übertrage sie mit einem USB-Kabel auf einen Computer. \n\n"<b>"Sichere deine Apps"</b>" \nAlle auf dieser <xliff:g id="NAME">^1</xliff:g> gespeicherten Apps werden deinstalliert und deren Daten werden gelöscht. Wenn du sie behalten möchtest, verschiebe sie in einen alternativen Speicher auf diesem Gerät."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Wenn du die <xliff:g id="NAME_0">^1</xliff:g> aus dem Gerät entfernst, funktionieren die auf dem Speichermedium vorhandenen Apps nicht mehr. Die gespeicherten Mediendateien können erst wieder auf dem Gerät aufgerufen werden, wenn du das Speichermedium einlegst."</b>" \n\nDie <xliff:g id="NAME_1">^1</xliff:g> ist nur für dieses Gerät formatiert und kann nicht mit anderen Geräten verwendet werden."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Zur Verwendung der Apps, Fotos oder Daten auf dieser <xliff:g id="NAME">^1</xliff:g> lege diese wieder ein. \n\nFalls das Speichermedium nicht verfügbar ist, kannst du es auch entfernen. \n\nWenn du es entfernst, gehen alle darauf befindlichen Daten endgültig verloren. \n\nDu kannst die Apps später erneut installieren, die Daten auf diesem Speichermedium gehen jedoch verloren."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"<xliff:g id="NAME">^1</xliff:g> entfernen?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Alle auf <xliff:g id="NAME">^1</xliff:g> gespeicherten Apps, Fotos und Daten gehen endgültig verloren."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"System enthält Dateien, die für die Ausführung von Android <xliff:g id="VERSION">%s</xliff:g> benötigt werden"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Nutzer im Gastmodus können SD-Karten nicht formatieren"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"<xliff:g id="NAME">^1</xliff:g> wird formatiert…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Entferne das Speichergerät (<xliff:g id="NAME">^1</xliff:g>) nicht, solange die Formatierung nicht abgeschlossen ist."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"<xliff:g id="NAME">^1</xliff:g> wurde formatiert"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"<xliff:g id="APP">^1</xliff:g> verschieben"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Das Verschieben von <xliff:g id="APP">^1</xliff:g> und der entsprechenden Daten auf die <xliff:g id="NAME_0">^2</xliff:g> dauert nur einen Moment. Du kannst die App erst wieder verwenden, nachdem sie vollständig verschoben wurde. \n\nEntferne die <xliff:g id="NAME_1">^2</xliff:g> während des Vorgangs nicht."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Um Daten zu verschieben, muss erst <xliff:g id="APP">^1</xliff:g> entsperrt werden."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"<xliff:g id="APP">^1</xliff:g> wird verschoben…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Entferne die <xliff:g id="NAME">^1</xliff:g> während des Vorgangs nicht. \n\nDie App <xliff:g id="APP">^2</xliff:g> auf diesem Gerät ist erst wieder verfügbar, nachdem sie vollständig verschoben wurde."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Wie möchtest du das Gerät (<xliff:g id="NAME">^1</xliff:g>) nutzen?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"oder"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"SD-Karte als mobilen Speicher formatieren"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Du kannst Fotos, Videos, Musik und mehr speichern und von anderen Geräten darauf zugreifen. &lt;a href=https://support.google.com/android/answer/12153449&gt;Weitere Informationen zum Einrichten von SD-Karten&lt;/a&gt;"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formatieren"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Später einrichten"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"<xliff:g id="NAME">^1</xliff:g> formatieren?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"<xliff:g id="NAME_0">^1</xliff:g> muss formatiert werden, damit du darauf Apps, Dateien und Medien speichern kannst. \n\nDurch das Formatieren werden alle vorhandenen Inhalte auf dem Speichergerät (<xliff:g id="NAME_1">^2</xliff:g>) gelöscht. Wenn du vermeiden möchtest, dass Inhalte verloren gehen, sichere sie auf einer anderen <xliff:g id="NAME_2">^3</xliff:g> oder einem anderen Gerät."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Diese <xliff:g id="NAME_0">^1</xliff:g> muss formatiert werden, um Fotos, Videos, Musik und mehr darauf speichern zu können. \n\nBeim Formatieren werden vorhandene Inhalte auf der <xliff:g id="NAME_1">^2</xliff:g> gelöscht. Wenn du vermeiden möchtest, dass Inhalte verloren gehen, sichere sie auf einer anderen <xliff:g id="NAME_2">^3</xliff:g> oder einem anderen Gerät."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"<xliff:g id="NAME">^1</xliff:g> formatieren"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Inhalte auf <xliff:g id="NAME">^1</xliff:g> verschieben?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Während des Verschiebens:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Entferne nicht das Speichergerät (<xliff:g id="NAME">^1</xliff:g>)"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Einige Apps funktionieren nicht"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Inhalte jetzt verschieben"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Inhalte später verschieben"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Inhalte werden verschoben…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Langsames Speichergerät (<xliff:g id="NAME">^1</xliff:g>)"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Du kannst <xliff:g id="NAME_0">^1</xliff:g> weiterhin verwenden, aber die Arbeitsgeschwindigkeit ist möglicherweise beeinträchtigt. \n\nDie auf dem Speichergerät (<xliff:g id="NAME_1">^2</xliff:g>) gespeicherten Apps funktionieren möglicherweise nicht korrekt und das Übertragen von Inhalten kann sehr lange dauern. \n\nVersuche, ein schnelleres Speichergerät (<xliff:g id="NAME_2">^3</xliff:g>) zu verwenden oder verwende stattdessen das Speichergerät (<xliff:g id="NAME_3">^4</xliff:g>) als mobilen Speicher."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Neu starten"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Weiter"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Deine <xliff:g id="NAME">^1</xliff:g> ist jetzt einsatzbereit"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Deine <xliff:g id="NAME">^1</xliff:g> ist jetzt einsatzbereit"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Deine <xliff:g id="NAME">^1</xliff:g> ist jetzt einsatzbereit"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Akkustatus"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Akkustand"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Gemeinschaftlich"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Gemeinschaftliche Einstellungen"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APNs"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Zugangspunkt bearbeiten"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Nicht definiert"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Nicht festgelegt"</string>
    <string name="apn_name" msgid="6677695784108157953">"Name"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proxy"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Port"</string>
    <string name="apn_user" msgid="5831763936428279228">"Nutzername"</string>
    <string name="apn_password" msgid="7435086635953953029">"Passwort"</string>
    <string name="apn_server" msgid="6997704279138388384">"Server"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"MMS-Proxy"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"MMS-Port"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Authentifizierungstyp"</string>
    <string name="apn_type" msgid="1835573305077788773">"APN-Typ"</string>
    <string name="apn_protocol" msgid="181529867160380010">"APN-Protokoll"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"APN-Roaming-Protokoll"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"APN aktivieren/deaktivieren"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN aktiviert"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN deaktiviert"</string>
    <string name="bearer" msgid="3231443241639159358">"Träger"</string>
    <string name="mvno_type" msgid="4734654257494971247">"MVNO-Typ"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"MVNO-Wert"</string>
    <string name="menu_delete" msgid="9199740901584348273">"APN löschen"</string>
    <string name="menu_new" msgid="6571230342655509006">"Neuer APN"</string>
    <string name="menu_save" msgid="6611465355127483100">"Speichern"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Abbrechen"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Das Namensfeld darf nicht leer sein."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"APN darf nicht leer sein."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"Das MCC-Feld muss 3 Zeichen enthalten."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"Das MNC-Feld muss 2 oder 3 Zeichen enthalten."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Der Anbieter erlaubt das Hinzufügen von APNs des Typs %s nicht."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Standard-APN-Einstellungen werden wiederhergestellt"</string>
    <string name="menu_restore" msgid="4310539620115151551">"Auf Standard zurücksetzen"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Zurücksetzen auf Standard-APN-Einstellungen abgeschlossen."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Optionen zum Zurücksetzen"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Einstellungen für Mobilfunknetze zurücksetzen"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Dadurch werden alle Einstellungen für Mobilfunknetze zurückgesetzt"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Mobilfunk-Einst. zurücksetzen?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Bluetooth und WLAN zurücksetzen"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Dadurch werden alle WLAN- und Bluetooth-Einstellungen zurückgesetzt. Diese Aktion lässt sich nicht rückgängig machen."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Zurücksetzen"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth und WLAN wurden zurückgesetzt"</string>
    <string name="erase_euicc_data_button" msgid="728078969563311737">"Löschen"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"eSIMs löschen"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Dein Mobilfunkvertrag wird dadurch nicht gekündigt. Wende dich an deinen Mobilfunkanbieter, um Ersatz-SIMs herunterzuladen."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Einstellungen zurücksetzen"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Sämtliche Netzwerkeinstellungen zurücksetzen? Dieser Vorgang kann nicht rückgängig gemacht werden."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Alle Netzwerkeinstellungen zurücksetzen und eSIMs löschen? Diese Aktion lässt sich nicht rückgängig machen."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Einstellungen zurücksetzen"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Zurücksetzen?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Das Zurücksetzen der Netzwerkeinstellungen ist für diesen Nutzer nicht verfügbar."</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Die Netzwerkeinstellungen wurden zurückgesetzt."</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"SIMs können nicht gelöscht werden"</string>
    <string name="reset_esim_error_msg" msgid="7279607120606365250">"eSIMs können aufgrund eines Fehlers nicht gelöscht werden.\n\nBitte starte dein Gerät neu und versuch es dann noch einmal."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Alle Daten löschen (auf Werkseinstellungen zurücksetzen)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Alle Daten löschen"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Musik"</li>\n<li>"Fotos"</li>\n<li>"Sonstige Nutzerdaten"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIMs"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Dein Mobilfunkvertrag wird dadurch nicht gekündigt."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Alle deine personenbezogenen Daten und heruntergeladenen Apps werden gelöscht. Dieser Vorgang kann nicht rückgängig gemacht werden."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Alle deine personenbezogenen Daten, einschließlich heruntergeladener Apps und SIMs, werden gelöscht. Dieser Vorgang kann nicht rückgängig gemacht werden."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Alle Daten löschen?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Das Zurücksetzen auf Werkseinstellungen ist für diesen Nutzer nicht verfügbar."</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Wird gelöscht…"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Bitte warten…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Anrufeinstellungen"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Mailbox, Rufweiterleitung, Anklopfen, Anruferkennung einrichten"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"USB-Tethering"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Mobiler Hotspot"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Bluetooth-Tethering"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Tethering"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Hotspot und Tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Hotspot aktiviert, Tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Hotspot aktiviert"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Tethering"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Tethering oder Verwendung von mobilen Hotspots nicht möglich, während der Datensparmodus aktiviert ist"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Nur Hotspot"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Nur USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Nur Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Nur Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Hotspot, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Hotspot, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Hotspot, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Hotspot, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Hotspot, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Hotspot, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Hotspot, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Internetverbindung wird nicht für andere Geräte freigegeben"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Aus"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Tethering"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"WLAN-Hotspot nicht verwenden"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Internet nur über USB freigeben"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Internet nur über Bluetooth teilen"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Internet nur über Ethernet freigeben"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Internet nur über USB und Bluetooth freigeben"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Internet nur über USB und Ethernet freigeben"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Internet nur über Bluetooth und Ethernet freigeben"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Internet nur über USB, Bluetooth und Ethernet freigeben"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"USB-Tethering"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Bluetooth-Tethering"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Ethernet-Tethering"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Mithilfe der Hotspot- und Tethering-Funktion kannst du deine mobile Datenverbindung für andere Geräte freigeben, damit diese eine Internetverbindung erhalten. Apps können ebenfalls einen Hotspot erstellen und so das Teilen von Inhalten mit Geräten in der Nähe ermöglichen."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Mithilfe der Hotspot- und Tethering-Funktion kannst du anderen Geräten erlauben, deine Internetverbindung (WLAN oder mobile Daten) mitzunutzen. Es gibt auch Apps für das Erstellen eines Hotspots, damit Inhalte mit Geräten in der Nähe geteilt werden können."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Hilfe"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobilfunknetz"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Mobilfunktarif"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"SMS-App"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"SMS-App wechseln?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"<xliff:g id="NEW_APP">%1$s</xliff:g> statt <xliff:g id="CURRENT_APP">%2$s</xliff:g> als SMS-App verwenden?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"<xliff:g id="NEW_APP">%s</xliff:g> als SMS-App verwenden?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"WLAN-Assistenten ändern?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"<xliff:g id="NEW_APP">%1$s</xliff:g> statt <xliff:g id="CURRENT_APP">%2$s</xliff:g> zur Verwaltung von Netzwerkverbindungen nutzen?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"<xliff:g id="NEW_APP">%s</xliff:g> zur Verwaltung von Netzwerkverbindungen nutzen?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Unbekannter SIM-Anbieter"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"<xliff:g id="OPERATOR">%1$s</xliff:g> hat keine bekannte Bereitstellungswebsite"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Lege die SIM ein und starte das Gerät neu."</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Bitte stelle eine Verbindung zum Internet her."</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Letzte Standortanfragen"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Standort für Arbeitsprofil"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Berechtigungen zur Standortermittlung"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Standortermittlung ist deaktiviert"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# von {total} Apps hat Zugriff auf den Standort}other{# von {total} Apps haben Zugriff auf den Standort}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Letzter Zugriff"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Alle ansehen"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Details ansehen"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Keine App hat kürzlich den Standort abgefragt."</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Kürzlich hat keine App auf den Standort zugegriffen"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Hoher Akkuverbrauch"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Geringer Akkuverbrauch"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"WLAN-Suche"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Wenn diese Funktion aktiviert ist, dürfen Apps und Dienste immer nach WLANs suchen, auch wenn die WLAN-Funktion deaktiviert ist. Dadurch können beispielsweise standortbasierte Funktionen und Dienste verbessert werden."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Bluetooth-Suche"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Wenn diese Funktion aktiviert ist, dürfen Apps und Dienste immer nach Geräten in der Nähe suchen, auch wenn Bluetooth deaktiviert ist. Dadurch können beispielsweise standortbasierte Funktionen und Dienste verbessert werden."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Standortdienste"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Standortdienste"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Standort verwenden"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Zeitzone kann nicht automatisch eingestellt werden"</string>
    <string name="location_time_zone_detection_status_summary_degraded_by_settings" msgid="6198939835335841106"></string>
    <string name="location_time_zone_detection_status_summary_blocked_by_settings" msgid="5276280770344278768">"Standort oder Standortdienste sind deaktiviert"</string>
    <string name="location_time_zone_detection_status_summary_blocked_by_environment" msgid="2279833212923765802"></string>
    <string name="location_time_zone_detection_status_summary_temporarily_unavailable" msgid="6586801403644278967"></string>
    <string name="location_time_zone_detection_location_is_off_dialog_title" msgid="231698690198001146">"Gerätestandort erforderlich"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Damit du die Zeitzone anhand deines Standorts einstellen kannst, musst du den Standortzugriff aktivieren und die Zeitzoneneinstellungen aktualisieren"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Standorteinstellungen"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Beheben"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Abbrechen"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Automatische Zeitzone ist deaktiviert"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Zeitzonenerkennung anhand des Standorts ist deaktiviert"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Zeitzonenerkennung anhand des Standorts wird nicht unterstützt"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Änderungen an den Einstellungen für die Zeitzonenerkennung sind nicht erlaubt"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Der Standort kann verwendet werden, um die Zeitzone festzulegen"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Rechtliche Hinweise, Status und Softwareversion anzeigen"</string>
    <string name="legal_information" msgid="7509900979811934843">"Rechtliche Hinweise"</string>
    <string name="manual" msgid="3651593989906084868">"Handbuch"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Zulassungszeichen"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Sicherheitsinformationen &amp; rechtliche Hinweise"</string>
    <string name="copyright_title" msgid="83245306827757857">"Urheberrecht"</string>
    <string name="license_title" msgid="8745742085916617540">"Lizenz"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Lizenzen für Google Play-Systemupdates"</string>
    <string name="terms_title" msgid="2071742973672326073">"Nutzungsbedingungen"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"System-WebView-Lizenz"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Quellenangaben für Hintergründe"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Satellitenbilder bereitgestellt von:\n© 2014 CNES/Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Handbuch"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Problem beim Laden des Handbuchs."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Lizenzen Dritter"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Beim Laden der Lizenzen ist ein Problem aufgetreten."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Wird geladen..."</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Wird geladen..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Passwort festlegen"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Passwort für Arbeitsprofil festlegen"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"PIN festlegen"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"PIN für Arbeitsprofil festlegen"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Muster festlegen"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Für zusätzliche Sicherheit ein Muster zum Entsperren des Geräts einrichten"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Muster für Arbeitsprofil festlegen"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Für Fingerabdruck Passwort festlegen"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Für Fingerabdruck Muster festlegen"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Richte zur Sicherheit eine PIN ein"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"PIN für Fingerabdruck festlegen"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Passwort noch einmal eingeben"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Passwort für Arbeitsprofil noch einmal eingeben"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Passwort deines Arbeitsprofils eingeben"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Muster bestätigen"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Arbeitsprofil-Muster eingeben"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"PIN noch einmal eingeben"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"PIN für Arbeitsprofil noch einmal eingeben"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"PIN deines Arbeitsprofils eingeben"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Die Passwörter stimmen nicht überein"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"Die PINs stimmen nicht überein"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Muster noch einmal zeichnen"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Sperre einrichten"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Das Passwort wurde festgelegt."</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"Die PIN wurde festgelegt."</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Das Muster wurde festgelegt."</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Für Gesichtsentsperrung Passwort festlegen"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Für Gesichtsentsperrung Muster festlegen"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Für Gesichtsentsperrung PIN festlegen"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Passwort festlegen"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Muster für Entsperrung per Gesicht oder Fingerabdruck einrichten"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"PIN für Entsperrung per Gesicht oder Fingerabdruck einrichten"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Passwort vergessen?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Muster vergessen?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"PIN vergessen?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7692794426682501482">"Gib zum Fortfahren das Muster für dein Gerät ein"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Gib zum Fortfahren die PIN für dein Gerät ein"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Gib zum Fortfahren das Passwort für dein Gerät ein"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Gib zum Fortfahren das Muster deines Arbeitsprofils ein"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Gib zum Fortfahren die PIN deines Arbeitsprofils ein"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Gib zum Fortfahren das Passwort deines Arbeitsprofils ein"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Verwende das Muster für dein Gerät, um die Sicherheit zu erhöhen"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Gib die PIN für dein Gerät ein, um die Sicherheit zu erhöhen"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Gib dein Gerätepasswort ein, um die Sicherheit zu erhöhen"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Verwende das Muster deines Arbeitsprofils, um die Sicherheit zu erhöhen"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Gib die PIN deines Arbeitsprofils ein, um die Sicherheit zu erhöhen"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Gib das Passwort deines Arbeitsprofils ein, um die Sicherheit zu erhöhen"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Muster bestätigen"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"PIN bestätigen"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Passwort bestätigen"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Identität bestätigen"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Gib das Muster für dein anderes Gerät ein, um Google-Konten, Einstellungen und mehr zu übertragen. Dein Muster wird verschlüsselt."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Gib die PIN für dein anderes Gerät ein, um Google-Konten, Einstellungen und mehr zu übertragen. Deine PIN wird verschlüsselt."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Gib das Passwort für dein anderes Gerät ein, um Google-Konten, Einstellungen und mehr zu übertragen. Dein Passwort wird verschlüsselt."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Muster auch zum Entsperren verwenden"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"PIN auch zum Entsperren verwenden"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Passwort auch zum Entsperren verwenden"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Falsche PIN"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Falsches Passwort"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Falsches Muster"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Notruf"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Gerätesicherheit"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Entsperrungsmuster ändern"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Entsperrungs-PIN ändern"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Zeichne ein Entsperrungsmuster"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Menütaste drücken, um die Hilfe aufzurufen"</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Wenn du fertig bist, lass das Display los"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Verbinde mindestens <xliff:g id="NUMBER">%d</xliff:g> Punkte. Bitte versuche es noch einmal."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Muster wurde aufgezeichnet"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Zeichne das Muster zur Bestätigung erneut"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Dein neues Entsperrungsmuster:"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Bestätigen"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Neu aufzeichnen"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Löschen"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Weiter"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Entsperrungsmuster"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Muster erforderlich"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Zum Entsperren muss ein Muster gezeichnet werden"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Muster sichtbar machen"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Erweiterter Datenschutz bei der PIN-Eingabe"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Animationen bei PIN-Eingabe deaktivieren"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Muster für das Profil anzeigen"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Bei Berührung vibrieren"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Ein/Aus sperrt Gerät sofort"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Außer bei dauerhafter Entsperrung durch <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Entsperrungsmuster"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Muster ändern"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Zeichnen eines Entsperrungsmusters"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Zu viele fehlerhafte Versuche. Bitte versuche es in <xliff:g id="NUMBER">%d</xliff:g> Sekunden erneut."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"App ist nicht auf dem Telefon installiert."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Sicherheit des Arbeitsprofils"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Displaysperre des Arbeitsprofils"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Einheitliche Sperre verwenden"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Einheitliche Sperre für Arbeitsprofil und Display verwenden"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Einheitliche Sperre verwenden?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Dein Gerät verwendet die Displaysperre des Arbeitsprofils. Die Arbeitsrichtlinien gelten für beide Sperren."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Die Sperre deines Arbeitsprofils entspricht nicht den Sicherheitsanforderungen deines Unternehmens. Du kannst für das Display und dein Arbeitsprofil dieselbe Sperre verwenden. In diesem Fall gelten jedoch sämtliche Richtlinien des Arbeitsprofils auch für die Displaysperre."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Einheitliche Sperre verwenden"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Einheitliche Sperre verwenden"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Identisch mit Displaysperre des Geräts"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Apps verwalten"</string>
    <string name="applications_settings" msgid="1941993743933425622">"App-Info"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"App-Einstellungen"</string>
    <string name="install_applications" msgid="3921609656584369901">"Unbekannte Herkunft"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Alle App-Quellen zulassen"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Kürzlich geöffnete Apps"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Alle Apps ansehen}other{Alle # Apps ansehen}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"IT-Administrator kontaktieren"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Der IT-Administrator hilft dir beim Zurücksetzen deiner PIN, deines Musters oder Passworts"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Erweiterte Einstellungen"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Weitere Einstellungsoptionen aktivieren"</string>
    <string name="application_info_label" msgid="1015706497694165866">"App-Info"</string>
    <string name="storage_label" msgid="2522307545547515733">"Speicher"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Standardmäßig öffnen"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Standardeinstellungen"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Bildschirmkompatibilität"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Berechtigungen"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Cache"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Cache leeren"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Cache"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 Element}other{# Elemente}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Zugriff löschen"</string>
    <string name="controls_label" msgid="8671492254263626383">"Steuerung"</string>
    <string name="force_stop" msgid="2681771622136916280">"Beenden erzwingen"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Insgesamt"</string>
    <string name="application_size_label" msgid="6407051020651716729">"App-Größe"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"USB-Speicher-App"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Nutzerdaten"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Deinstallieren"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Für alle Nutzer deinstallieren"</string>
    <string name="install_text" msgid="4558333621516996473">"Installieren"</string>
    <string name="disable_text" msgid="5146002260857428005">"Deaktivieren"</string>
    <string name="enable_text" msgid="8570798764647110430">"Aktivieren"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Speicherinhalt löschen"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Updates deinstallieren"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Eingeschränkte Einstellungen zulassen"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Einige von dir ausgewählte Aktivitäten werden standardmäßig in dieser App geöffnet."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Du hast dieser App das Erstellen von Widgets und den Zugriff auf deine Daten erlaubt."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Kein Standard"</string>
    <string name="clear_activities" msgid="488089228657585700">"Standardeinstellungen löschen"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Möglicherweise ist diese App nicht für deinen Bildschirm ausgelegt. Hier kannst du festlegen, wie sie an deinen Bildschirm angepasst wird."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Beim Start fragen"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"App skalieren"</string>
    <string name="unknown" msgid="8192160131923461175">"Unbekannt"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Nach Name sortieren"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Nach Größe sortieren"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Letzte"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Häufigste"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Aktive Dienste anzeigen"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Prozesse im Cache anzeigen"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"App für Notfallbenachrichtigungen"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"App-Einstellungen zurücksetzen"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"App-Einstellungen zurücksetzen?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Dadurch werden die folgenden Einstellungen zurückgesetzt:\n\n"<li>"Deaktivierung von Apps"</li>\n<li>"Deaktivierung von App-Benachrichtigungen"</li>\n<li>"Festlegung von Standard-Apps für bestimmte Aktionen"</li>\n" "<li>"Einschränkungen der Hintergrunddaten für Apps"</li>\n<li>"Jegliche Zugriffsbeschränkungen"</li>\n<li>"Einstellungen für die Akkunutzung"</li>\n\n"Alle App-Daten bleiben erhalten."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Apps zurücksetzen"</string>
    <string name="filter" msgid="9039576690686251462">"Filter"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Filteroptionen auswählen"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Alle Apps"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Deaktivierte Apps"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Heruntergeladen"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Aktiv"</string>
    <string name="not_installed" msgid="5074606858798519449">"Nicht für Nutzer installiert"</string>
    <string name="installed" msgid="2837449358488825884">"Installiert"</string>
    <string name="no_applications" msgid="985069304755391640">"Keine Apps"</string>
    <string name="internal_storage" msgid="999496851424448809">"Interner Speicher"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Größe wird neu berechnet..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"App-Daten löschen?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Die Daten dieser App, einschließlich Dateien und Einstellungen, werden endgültig von diesem Gerät gelöscht"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"Ok"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Abbrechen"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Löschen"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Die App wurde nicht in der Liste der installierten Apps gefunden."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Speicherinhalt der App konnte nicht gelöscht werden."</string>
    <string name="computing_size" msgid="4915310659841174866">"Berechnung..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Paketgröße konnte nicht berechnet werden."</string>
    <string name="version_text" msgid="7628938665256107608">"Version <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Verschieben"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Es wird schon eine andere Migration durchgeführt."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Nicht genügend Speicherplatz"</string>
    <string name="does_not_exist" msgid="6499163879348776120">"App ist nicht vorhanden."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Installationspfad ist nicht gültig."</string>
    <string name="system_package" msgid="7559476279008519360">"Systemupdates können nicht auf externen Datenträgern installiert werden."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Die App zur Geräteverwaltung kann nicht auf externen Medien installiert werden"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Beenden erzwingen?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Das Beenden der App zu erzwingen kann zu unerwünschtem Verhalten führen."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"App deaktivieren"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Bei Deaktivierung dieser App funktionieren Android und andere Apps möglicherweise nicht mehr ordnungsgemäß. Beachte hierbei, dass du diese App nicht löschen kannst, weil sie auf deinem Gerät vorinstalliert war. Durch die Deaktivierung schaltest du diese App ab und blendest sie auf deinem Gerät aus."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"App-Shop"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"App-Details"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"App installiert vom <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Weitere Informationen im <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Aktiv"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nie verwendet)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Speichernutzung"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Neustart wird durchgeführt..."</string>
    <string name="cached" msgid="5379485147573438201">"Hintergrundprozess im Cache"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Nichts wird ausgeführt."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Von der App gestartet"</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"<xliff:g id="MEMORY">%1$s</xliff:g> frei"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> belegt"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Nutzer: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Nutzer entfernt"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> Prozess und <xliff:g id="NUMSERVICES">%2$d</xliff:g> Dienst"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> Prozess und <xliff:g id="NUMSERVICES">%2$d</xliff:g> Dienste"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> Prozesse und <xliff:g id="NUMSERVICES">%2$d</xliff:g> Dienst"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> Prozesse und <xliff:g id="NUMSERVICES">%2$d</xliff:g> Dienste"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Gerätespeicher"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"App-RAM-Nutzung"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"System"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Apps"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Frei"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Belegt"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Im Cache"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Aktive App"</string>
    <string name="no_services" msgid="3898812785511572899">"Nicht aktiv"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Dienste"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Prozesse"</string>
    <string name="service_stop" msgid="5712522600201308795">"Beenden"</string>
    <string name="service_manage" msgid="3896322986828332075">"Einstellungen"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Dieser Dienst wurde von seiner App gestartet. Wird er beendet, kann die App eventuell nicht mehr ausgeführt werden."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Diese App kann nicht sicher beendet werden. Beim Beenden könnten aktuelle Daten verloren gehen."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Hierbei handelt es sich um einen alten App-Prozess, der für den Fall, dass er wieder benötigt wird, beibehalten wird. Normalerweise gibt es keinen Grund zur Beendigung."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: wird zurzeit verwendet. Tippe zum Verwalten auf die Einstellungen."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Hauptprozess wird verwendet."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Dienst <xliff:g id="COMP_NAME">%1$s</xliff:g> wird verwendet."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Anbieter <xliff:g id="COMP_NAME">%1$s</xliff:g> wird verwendet."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Systemdienst beenden?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Sprachen, Eingabe und Gesten"</string>
    <string name="language_settings" msgid="8700174277543875046">"Sprachen und Eingabe"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Sprachen"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Tastatur"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Du bist nicht berechtigt, die Sprache des Geräts zu ändern."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Sprachen und Eingabe"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Tools"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Tastatur &amp; Eingabemethoden"</string>
    <string name="system_language" msgid="1146762166579643257">"Systemsprachen"</string>
    <string name="phone_language" msgid="5986939176239963826">"Sprachen"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automatisch ersetzen"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Tippfehler korrigieren"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Autom. Groß-/Kleinschreibung"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Jeden Satz mit einem Großbuchstaben beginnen"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Automatische Zeichensetzung"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Einstellungen für physische Tastatur"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Leertaste zweimal drücken, um \".\" hinzuzufügen"</string>
    <string name="show_password" msgid="7101900779571040117">"Passwörter anzeigen"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Zeichen während der Eingabe kurz anzeigen"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Diese Rechtschreibprüfung kann den gesamten von dir eingegebenen Text erfassen, einschließlich personenbezogener Daten wie Passwörter und Kreditkartennummern. Sie ist Teil der App \"<xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>\". Möchtest du die Rechtschreibprüfung verwenden?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Einstellungen"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Sprache"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Tastaturen"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Bildschirmtastatur"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Verfügbare Bildschirmtastatur"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Bildschirmtastaturen verwalten"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Optionen"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Physische Tastatur"</string>
    <string name="show_ime" msgid="4334255501724746849">"Bildschirmtastatur verwenden"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Bildschirmtastatur auch dann anzeigen, wenn physische Tastatur aktiv ist"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Tastenkürzel"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Liste der Tastenkombinationen anzeigen"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastaturen und Tools für das Arbeitsprofil"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Bildschirmtastatur für das Arbeitsprofil"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Standard"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Touchpad"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Touchpad und Maus"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Zeigergeschwindigkeit, Touch-Gesten"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Touchpad-Klick"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Touchpad-Gesten"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Individuelle Touchpad-Gesten für die Navigation festlegen"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Scrollrichtung umkehren"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Inhalte bewegen sich nach oben, wenn du nach unten scrollst"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Unten rechts tippen"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Tippe unten rechts auf das Touchpad für weitere Optionen"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Zeigergeschwindigkeit"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Informationen zu Touchpad-Gesten"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Zum StartU+00ADbildschirm"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Wische irgendwo auf dem Touchpad mit drei Fingern nach oben"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Zurück"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Wische mit drei Fingern von links oder rechts"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Letzte Apps aufrufen"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Wische mit drei Fingern nach oben, halte und lass los"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Benachricht. &amp; Schnelleinstell."</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Wische auf dem Startbildschirm mit drei Fingern nach unten"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Apps wechseln"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Wische mit vier Fingern nach links oder rechts"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Überspr."</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Weiter"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Neustart"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Fertig"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Zurück"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Wische mit drei Fingern nach links oder rechts"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Zur Startseite"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Wische mit drei Fingern nach oben"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Zuletzt verwendete Apps"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Wische mit drei Fingern nach oben und halte"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Benachrichtigungen"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Wische mit drei Fingern nach unten"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Apps wechseln"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Wische mit vier Fingern nach links oder rechts"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Modifikatortasten"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Verhalten von Tasten ändern"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Alle zurücksetzen"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Standard"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Möchtest du alle Modifikatortasten auf die Standardeinstellungen zurücksetzen?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Fertig"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Abbrechen"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Zurücksetzen"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Modifikatortaste wählen"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Wähle eine neue Taste für <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Standard"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Spracheingabe, -erkennung und -ausgabe"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Zeigergeschwindigkeit"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Gamecontroller"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Vibration weiterleiten"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Vibration an Gamecontroller senden, sofern eine Verbindung besteht"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Tastaturlayout wählen"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Tastaturlayouts einrichten"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Drücke zum Wechseln Strg+Leertaste."</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Standard"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Tastaturlayouts"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Tastaturlayouts"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Mein Wörterbuch"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Persönliches Wörterbuch für die Arbeit"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Wörter für die Verwendung in Apps wie der Rechtschreibprüfung hinzufügen"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Hinzufügen"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Ins Wörterbuch"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Wort"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Mehr Optionen"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Weniger Optionen"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Wort:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Tastaturkürzel:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Sprache:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Wort eingeben"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Optionales Tastaturkürzel"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Wort bearbeiten"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Bearbeiten"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Löschen"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Es sind noch keine Wörter in deinem Wörterbuch vorhanden. Du kannst Wörter hinzufügen, indem du auf das „+“-Symbol tippst."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Für alle Sprachen"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Weitere Sprachen..."</string>
    <string name="testing" msgid="6294172343766732037">"Test"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Bildschirmtastatur, Tools"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Bildschirmtastatur, physische Tastatur, Tools"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Physische Tastatur"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Layout"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Gadget auswählen"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Widget auswählen"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Widget erstellen und Zugriff erlauben?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Nach der Erstellung des Widgets hat die App Zugriff auf alle angezeigten Daten.\n\nApp: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nWidget: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"<xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> immer das Erstellen von Widgets und den Zugriff auf ihre Daten erlauben"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Nutzungsstatistik"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Nach Nutzungszeit sortieren"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Nach „Zuletzt verwendet“ sortieren"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Nach App-Name sortieren"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Zuletzt verwendet"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Nutzungszeit"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Bedienungshilfen"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Einstellungen für Bedienungshilfen"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Display, Interaktion, Audio"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Ein­stellungen für Seh­behinderte"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Du kannst dieses Gerät an deine Bedürfnisse anpassen. Die Bedienungshilfen kannst du später in den Einstellungen ändern."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Schriftgröße ändern"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Screenreader"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Untertitel"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Allgemein"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Display"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Farbe und Bewegung"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Bildschirm dunkler machen"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaktionssteuerung"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Einstellungen für Zeitvorgaben"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"System­steuerelemente"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Heruntergeladene Apps"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Experimentell"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Funktions-Flags"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filterung durch Bluetooth HCI-Snoop-Protokoll"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Filter festlegen"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Bluetooth zum Übernehmen der Änderungen aus- und wieder einschalten"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"PBAP-Filterung durch Bluetooth HCI-Snoop-Protokoll"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"MAP-Filterung durch Bluetooth HCI-Snoop-Protokoll"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Wähle den Filtermodus aus. (Bluetooth zum Übernehmen der Änderungen aus- und wieder einschalten)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Setze den Bluetooth HCI-Snoop-Protokollmodus zum Ändern dieser Option auf „Filter aktiviert“"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Der Screenreader ist in erster Linie für Blinde und Menschen mit eingeschränktem Sehvermögen bestimmt"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Auf dem Bildschirm auf Elemente tippen, damit sie vorgelesen werden"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Untertitel-Einstellungen"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Über die Einstellungen für Untertitel"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Weitere Informationen zu den Einstellungen für Untertitel"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Vergrößerung"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Kurzbefehl für Vergrößerung"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Eingetippten Text vergrößern"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Lupe folgt dem Text, während du tippst"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Beim App-Wechsel aktiviert lassen"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Vergrößerung bleibt aktiviert und es wird herausgezoomt, wenn du zwischen Apps wechselst"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Joystick"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Du kannst die Lupe aktivieren und mit dem Joystick auf dem Bildschirm bewegen. Halte den Joystick gedrückt und ziehe, um die Lupe zu bewegen. Tippe und ziehe, um den Joystick zu verschieben."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Über die Vergrößerung"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Weitere Informationen zur Vergrößerung"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Art der Vergrößerung"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Den gesamten Bildschirm oder einen bestimmten Bereich vergrößern und zwischen beiden Optionen wechseln"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Ganzer Bildschirm"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Teil des Bildschirms"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Zwischen dem ganzen Bildschirm und einem Teil des Bildschirms wechseln"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Wählen, wie vergrößert werden soll"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Ganzen Bildschirm vergrößern"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Teil des Bildschirms vergrößern"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Zwischen dem ganzen Bildschirm und einem Teil des Bildschirms wechseln"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Tippe auf die Schaltfläche zum Ändern der Ansicht, um zwischen beiden Optionen zu wechseln"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Zur Schaltfläche „Bedienungshilfen“ wechseln?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Wenn du den Kurzbefehl „Dreimal tippen“ verwendest, um einen Teil des Bildschirms zu vergrößern, verzögern sich die Texteingabe und andere Aktionen.\n\nDie Schaltfläche „Bedienungshilfen“ wird unverankert über anderen Apps auf deinem Bildschirm angezeigt. Tippe darauf, um Inhalte zu vergrößern."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Zur Schaltfläche „Bedienungshilfen“ wechseln"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"„Dreimal tippen“ verwenden"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Dadurch kann deine Tastatur langsamer werden"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Wenn du den Kurzbefehl „Dreimal tippen“ verwendest, um einen Teil des Displays zu vergrößern, kann es zu Problemen mit der Tastatur kommen.\n\nUm das zu vermeiden, kannst du den Kurzbefehl für die Vergrößerung von „Dreimal tippen“ zu einer anderen Option ändern.\n"<annotation id="link">"Einstellung ändern"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Trotzdem fortfahren"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Abbrechen"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Vergrößerungseinstellungen"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Dreimal tippen zum Vergrößern"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Mit Tastenkombination vergrößern"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Mit Tastenkombination und 3-mal Tippen vergrößern"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Die Bedienungshilfe „<xliff:g id="SERVICE">%1$s</xliff:g>“"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Anzeigegröße und Text"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Einstellungen für Textanzeige ändern"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Betreff: Designs für Heißluftballons"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Von: Bernd"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Guten Morgen,\n\nwie geht es mit den Entwürfen voran? Werden sie fertig sein, bevor wir mit der Herstellung der neuen Ballons beginnen?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Einstellungen zurücksetzen"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Einstellungen für Anzeigegröße und Text wurden zurückgesetzt"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Anzeigegröße und Text zurücksetzen?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Zurücksetzen"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Hast du Pläne fürs Wochenende?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Ich will zum Strand. Kommst du mit?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Optionen"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Auf dem Bildschirm heranzoomen"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Zum Zoomen dreimal tippen"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Zum Zoomen auf eine Schaltfläche tippen"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Du kannst auf dem Display schnell heranzoomen, um Inhalte zu vergrößern"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;So zoomst du heran:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Starte die Vergrößerung über den Kurzbefehl&lt;br/&gt; {1,number,integer}. Tippe auf das Display&lt;br/&gt; {2,number,integer}. Ziehe mit zwei Fingern, um den angezeigten Bildschirmausschnitt zu ändern&lt;br/&gt; {3,number,integer}. Ziehe zwei Finger auseinander oder zusammen, um den Zoom anzupassen&lt;br/&gt; {4,number,integer}. Beende die Vergrößerung über den Kurzbefehl&lt;br/&gt;&lt;br/&gt; &lt;b&gt;So zoomst du vorübergehend heran:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Achte darauf, dass als Art der Vergrößerung „Vollbild“ ausgewählt ist&lt;br/&gt; {1,number,integer}. Starte die Vergrößerung über den Kurzbefehl&lt;br/&gt; {2,number,integer}. Halte eine beliebige Stelle auf dem Display gedrückt&lt;br/&gt; {3,number,integer}. Ziehe mit dem Finger, um den angezeigten Bildschirmausschnitt zu ändern&lt;br/&gt; {4,number,integer}. Hebe den Finger, um die Vergrößerung zu beenden"</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Wenn die Vergrößerung aktiviert ist, kannst du Elemente auf dem Bildschirm heranzoomen.\n\n"<b>"Wenn du zoomen möchtest"</b>", starte die Vergrößerung und tippe dann auf eine beliebige Stelle auf dem Bildschirm.\n"<ul><li>"Zum Scrollen ziehe mit zwei oder mehr Fingern"</li>\n<li>"Zum Anpassen des Zooms ziehe zwei oder mehr Finger zusammen bzw. auseinander"</li></ul>\n\n<b>"Wenn du vorübergehend heranzoomen möchtest"</b>", starte die Vergrößerung und tippe dann auf eine beliebige Stelle auf dem Bildschirm und halte sie gedrückt.\n"<ul><li>"Wenn du den angezeigten Bildschirmausschnitt verschieben möchtest, ziehe den Bildschirm"</li>\n<li>"Zum Herauszoomen hebe den Finger"</li></ul>\n\n"In die Tastatur oder Navigationsleiste kann nicht hineingezoomt werden."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Seite <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> von <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Zum Öffnen Schaltfläche „Bedienungshilfen“ nutzen"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Zum Öffnen die Lautstärketasten gedrückt halten"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Zum Öffnen dreimal auf das Display tippen"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Zum Öffnen Touch-Geste verwenden"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Touch-Geste für Bedienungshilfen verwenden"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Wenn du diese Funktion verwenden möchtest, tippe unten auf dem Display auf die Schaltfläche \"Bedienungshilfen\" <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nWenn du zwischen den Funktionen wechseln möchtest, halte diese Schaltfläche gedrückt."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Tippe zum Verwenden dieser Funktion auf dem Display auf die Schaltfläche „Bedienungshilfen“."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Wenn du diese Funktion verwenden möchtest, halte beide Lautstärketasten gedrückt."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Tippe dreimal auf das Display, um die Vergrößerung zu starten oder zu beenden."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Wenn du diese Funktion verwenden möchtest, wische vom unteren Displayrand mit zwei Fingern nach oben.\n\nWenn du zwischen den Funktionen wechseln möchtest, wische mit zwei Fingern über das Display nach oben und halte."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Wenn du diese Funktion verwenden möchtest, wische vom unteren Displayrand mit drei Fingern nach oben.\n\nWenn du zwischen den Funktionen wechseln möchtest, wische mit drei Fingern über das Display nach oben und halte."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Wenn du eine Bedienungshilfe verwenden möchtest, wische vom unteren Displayrand mit zwei Fingern nach oben.\n\nWenn du zwischen den Funktionen wechseln möchtest, wische mit zwei Fingern über das Display nach oben und halte."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Wenn du eine Bedienungshilfe verwenden möchtest, wische vom unteren Displayrand mit drei Fingern nach oben.\n\nWenn du zwischen den Funktionen wechseln möchtest, wische mit drei Fingern über das Display nach oben und halte."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"OK"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="1624189347106713695">"Einstellungen für die Schaltfläche „Bedienungshilfen“"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Kurzbefehl für „<xliff:g id="SERVICE">%1$s</xliff:g>“"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Schaltfläche „Bedienungshilfen“"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Touch-Geste für Bedienungshilfen"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Mit zwei Fingern nach oben wischen"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Mit drei Fingern nach oben wischen"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Auf Schaltfläche „Bedienungshilfen“ tippen"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Touch-Geste für Bedienungshilfen verwenden"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Tippe unten auf dem Bildschirm auf die Schaltfläche \"Bedienungshilfen\" <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>.\n\nWenn du zwischen den Funktionen wechseln möchtest, halte diese Schaltfläche gedrückt."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Wische vom unteren Bildschirmrand mit zwei Fingern nach oben.\n\nWenn du zwischen den Funktionen wechseln möchtest, wische mit zwei Fingern über das Display nach oben und halte."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Wische vom unteren Bildschirmrand mit drei Fingern nach oben.\n\nWenn du zwischen den Funktionen wechseln möchtest, wische mit drei Fingern über das Display nach oben und halte."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Weitere Optionen"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Weitere Informationen zu <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Lautstärketasten gedrückt halten"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"Lautstärketasten gedrückt halten"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Halte beide Lautstärketasten gedrückt"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Dreimal auf den Bildschirm tippen"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"dreimal auf den Bildschirm tippen"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Tippe {0,number,integer}-mal schnell auf das Display. Durch diesen Kurzbefehl  kann dein Gerät langsamer werden."</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Erweitert"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Die Schaltfläche für die Bedienungshilfen ist auf <xliff:g id="SERVICE">%1$s</xliff:g> gestellt. Um die Vergrößerung nutzen zu können, tippe &amp; halte die Schaltfläche für die Bedienungshilfen gedrückt und wähle anschließend \"Vergrößerung\" aus."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Die Touch-Geste für die Bedienungshilfen ist auf den Dienst \"<xliff:g id="SERVICE">%1$s</xliff:g>\" eingestellt. Wenn du die Vergrößerung verwenden möchtest, wische mit zwei Fingern vom unteren Bildschirmrand nach oben und halte den Bildschirm gedrückt. Wähle dann \"Vergrößerung\" aus."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Verknüpfung für Lautstärketaste"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Einstellungen für Verknüpfungen"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Verknüpfung auf dem Sperrbildschirm"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Du kannst zulassen, dass die Bedienungshilfenverknüpfung auch vom Sperrbildschirm aus funktioniert. Halte dazu beide Lautstärketasten für einige Sekunden gedrückt."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Schaltfläche „Bedienungshilfen“"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Bedienungshilfen &amp; Touch-Geste"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Du kannst auf allen Bildschirmen schnell auf Bedienungshilfen zugreifen"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Über die Schaltfläche „Bedienungshilfen“"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Über die Schaltfläche „Bedienungshilfen“ und Gesten"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Weitere Informationen zur Schaltfläche „Bedienungshilfen“ und zu Gesten"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Schaltfläche „Bedienungshilfen“ wird verwendet. Bei Bedienung über 3 Schaltflächen ist die Touch-Geste nicht verfügbar."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Schnell auf Bedienungshilfen zugreifen"</string>
    <string name="accessibility_button_gesture_description" msgid="7507097717493960397"><b>"Die ersten Schritte"</b>\n"1. Gehe zu den Einstellungen für Bedienungshilfen\n2. Wähle eine Funktion aus und tippe auf das Tastenkürzel\n3. Wähle aus, ob du eine Taste oder eine Touch-Geste für den Zugriff auf die Funktion verwenden möchtest"</string>
    <string name="accessibility_button_description" msgid="1261273371298608222"><b>"Die ersten Schritte"</b>\n"1. Gehe zu den Einstellungen für Bedienungshilfen\n2. Wähle eine Funktion aus und tippe auf das Tastenkürzel\n3. Wähle die Taste aus, die du für den Zugriff auf die Funktion verwenden möchtest"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Schaltfläche oder Touch-Geste verwenden"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Ort"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Größe"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Bei Nichtnutzung ausblenden"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Wird nach einigen Sekunden ausgeblendet, damit du den Bildschirm besser siehst"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Transparenzgrad bei Nichtnutzung"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Transparent"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Nicht transparent"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Text mit hohem Kontrast"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Textfarbe in Schwarz oder Weiß ändern. Maximiert den Kontrast zum Hintergrund."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Vergrößerung automatisch aktualisieren"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Vergrößerung bei App-Übergängen aktualisieren"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Ein/Aus-Taste beendet Anruf"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Großer Mauszeiger"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Sichtbarkeit des Mauszeigers verbessern"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Animationen entfernen"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Bewegung auf dem Bildschirm verringern"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Mono-Audio"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Kanäle bei Audiowiedergabe kombinieren"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Audiobalance"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Links"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Rechts"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Standard"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 Sekunden"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 Sekunden"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 Minute"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 Minuten"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Zeit zum Reagieren"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Über die Zeit zum Reagieren (Zeitüberschreitung bei Bedienungshilfen)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Weitere Informationen über die Zeit zum Reagieren (Zeitüberschreitung bei Bedienungshilfen)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Zeit zum Reagieren"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Diese Einstellung für die Dauer wird nicht von allen Apps unterstützt"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Hier kannst du festlegen, wie lange vorübergehende Nachrichten angezeigt werden, die dich zum Handeln auffordern"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Reaktionszeit für langes Drücken"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Farbumkehr"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Farbumkehr aktivieren"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Kurzbefehl für Farbumkehr"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Die Farbumkehr macht helle Displays dunkel. Und sie macht dunkle Displays hell."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Hinweis&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Das führt zu einer veränderten Wiedergabe der Farben in Medien und Bildern&lt;/li&gt; &lt;li&gt; Die Farbumkehr funktioniert in allen Apps&lt;/li&gt; &lt;li&gt; Ein dunkler Hintergrund kann stattdessen mit dem dunklen Design angezeigt werden&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Automatischer Klick (Verweildauer)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Über automatischer Klick (Verweildauer)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Weitere Informationen zu automatischen Klicks (Verweildauer)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Du kannst eine verbundene Maus so einstellen, dass sie automatisch klickt, wenn sich der Cursor für eine bestimmte Zeit nicht bewegt"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Die Funktion \"automatischer Klick\" kann nützlich sein, wenn es schwierig ist, mit der Maus zu klicken"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Automatischer Klick deaktivieren"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Kurz"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 Sekunden"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Mittel"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 Sekunden"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Lang"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 Sekunde"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Benutzerdefiniert"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Kürzer"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Länger"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Zeit vor automatischem Klick"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibration und haptisches Feedback"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Vibrationsstärke für verschiedene Anwendungsfälle anpassen"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"An"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Aus"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Einstellung deaktiviert, da das Gerät stummgeschaltet ist"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Anrufe"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Benachrichtigungen und Wecker"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Haptische Rückmeldungen bei Nutzerinteraktionen"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Vibration &amp; haptisches Feedback verwenden"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Vibration für Wecker"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Vibration für Medien"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibration bei Klingeln"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibration bei Benachrichtigungseingang"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Haptisches Feedback"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> verwenden"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> öffnen"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"„<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>“ wurde zu den Schnelleinstellungen hinzugefügt. Du kannst jederzeit nach unten wischen und die Funktion aktivieren oder deaktivieren."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Du kannst „<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>“ auch vom oberen Rand des Bildschirms in die Schnelleinstellungen aufnehmen"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Die Farbkorrektur wurde zu den Schnelleinstellungen hinzugefügt. Du kannst jederzeit nach unten wischen und die Funktion aktivieren oder deaktivieren."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Du kannst die Farbkorrektur auch vom oberen Rand des Bildschirms in die Schnelleinstellungen aufnehmen"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Die Farbumkehr wurde zu den Schnelleinstellungen hinzugefügt. Du kannst jederzeit nach unten wischen und die Funktion aktivieren oder deaktivieren."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Du kannst die Farbumkehr auch vom oberen Rand des Bildschirms in die Schnelleinstellungen aufnehmen"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Die Funktion „Extradunkel“ wurde zu den Schnelleinstellungen hinzugefügt. Du kannst jederzeit nach unten wischen und die Funktion aktivieren oder deaktivieren."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Du kannst die Funktion „Extradunkel“ auch vom oberen Rand des Bildschirms in die Schnelleinstellungen aufnehmen"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Der Einhandmodus wurde zu den Schnelleinstellungen hinzugefügt. Du kannst jederzeit nach unten wischen und die Funktion aktivieren oder deaktivieren."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Du kannst den Einhandmodus auch vom oberen Rand des Bildschirms in die Schnelleinstellungen aufnehmen"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Schriftgröße wurde zu den Schnelleinstellungen hinzugefügt. Du kannst jederzeit nach unten wischen, um sie zu ändern."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Schließen"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Farbkorrektur aktivieren"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Kurzbefehl für Farbkorrektur"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Über die Farbkorrektur"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Weitere Informationen zur Farbkorrektur"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Über die Farbumkehr"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Weitere Informationen zur Farbumkehr"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Untertitel anzeigen"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Nur für unterstützte Apps"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Untertitelgröße und -stil"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Textgröße: <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Weitere Optionen"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Hier kannst du den Stil und die Größe der Untertitel anpassen, damit sie einfacher zu lesen sind"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Diese Einstellungen für Untertitel werden nicht von allen Medien-Apps unterstützt"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Schaltfläche „Bedienungshilfen“"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Mit zwei Fingern nach oben wischen"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Lautstärketasten gedrückt halten"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Dreimal auf den Bildschirm tippen"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Weiter"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Hörgeräte"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Du kannst Hörgeräte, Cochlea-Implantate und andere Audioverstärker mit deinem Smartphone koppeln"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Keine Hörgeräte verbunden"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Hörgeräte hinzufügen"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Hörgeräte koppeln"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Wähle auf dem nächsten Bildschirm deine Hörgeräte aus. Das linke und rechte Ohr müssen möglicherweise separat gekoppelt werden.\n\nDeine Hörgeräte müssen eingeschaltet und bereit zum Koppeln sein."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> aktiv"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, nur links"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, nur rechts"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, links und rechts"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> + 1 weiteres"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Neues Gerät koppeln"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"Informationen zum Koppeln eines neuen Geräts"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Hörgeräte"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Gespeicherte Geräte"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Steuerung von Hörgeräten"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Verknüpfung für Hörgeräte"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilität mit Hörgeräten"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Bessere Kompatibilität mit Telefonspulen und Reduzierung unerwünschter Geräusche"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Informationen zu Hörgeräten"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Dein Hörgerät muss eingeschaltet und bereit zum Koppeln sein"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Hörgerät koppeln"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Verfügbare Hörgeräte"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Du siehst dein Hörgerät nicht?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Mehr Geräte ansehen"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Audioanpassung"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Audiobeschreibung"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Höre dir bei unterstützten Filmen und Serien eine Beschreibung der Ereignisse auf dem Bildschirm an"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"Audiobeschreibung, Audio, Beschreibung, eingeschränktes Sehvermögen"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Kurzbefehl aktiviert"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Aus"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"An"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Aus"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Fehler. Tippen, um weitere Informationen zu erhalten."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Dieser Dienst funktioniert nicht."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Kurzbefehle für Bedienungshilfen"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"In Schnelleinstellungen anzeigen"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Rot-Grün-Sehschwäche"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Rot-Grün-Sehschwäche"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Blau-Gelb-Sehschwäche"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Graustufen"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Grün-Sehschwäche, Deuteranomalie"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Rot-Sehschwäche, Protanomalie"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomalie"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Extradunkel"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Display extradunkel aktivieren"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Kurzbefehl für Extradunkel"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Über die Funktion „Extradunkel“"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Hier kannst du dein Display dunkler machen, um beim Lesen die Augen zu schonen"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensität"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Dunkler"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Heller"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Nach dem Neustart des Geräts beibehalten"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Kurz ({time} Sekunde)}other{Kurz ({time} Sekunden)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Mittel ({time} Sekunde)}other{Mittel ({time} Sekunden)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Lang ({time} Sekunde)}other{Lang ({time} Sekunden)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} Sekunde}other{{time} Sekunden}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Einstellungen"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"An"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Aus"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Vorschau"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standardoptionen"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Sprache"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Textgröße"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Untertitelstil"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Benutzerdefinierte Optionen"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Hintergrundfarbe"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Hintergrundtransparenz"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Farbe der Untertitel-Fenster"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Deckkraft der Untertitel-Fenster"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Schriftfarbe"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Texttransparenz"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Rahmenfarbe"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Rahmentyp"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Schriftfamilie"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Untertitel sehen so aus."</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Standard"</string>
    <string name="color_title" msgid="2511586788643787427">"Farbe"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Standard"</string>
    <string name="color_none" msgid="3703632796520710651">"Keine"</string>
    <string name="color_white" msgid="1896703263492828323">"Weiß"</string>
    <string name="color_gray" msgid="8554077329905747877">"Grau"</string>
    <string name="color_black" msgid="9006830401670410387">"Schwarz"</string>
    <string name="color_red" msgid="5210756997426500693">"Rot"</string>
    <string name="color_green" msgid="4400462091250882271">"Grün"</string>
    <string name="color_blue" msgid="4997784644979140261">"Blau"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Blaugrün"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Gelb"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"„<xliff:g id="SERVICE">%1$s</xliff:g>“ die vollständige Kontrolle über dein Gerät geben?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> muss:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Deine Eingabe wird von \"Einstellungen\" nicht erkannt, weil die Berechtigungsanfrage von einer App verdeckt wird."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> fordert eine volle Kontrolle für dieses Gerät an. Der Dienst kann den Bildschirm lesen und im Namen von Nutzern mit Bedarf an Bedienungshilfen handeln. Dieses Maß an Kontrolle ist für die meisten Apps ungeeignet."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Die vollständige Kontrolle sollte nur für Apps aktiviert werden, die dir Zugang zu App-Funktionen erleichtern. Das ist in der Regel nur ein kleiner Teil der Apps."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Bildschirm aufrufen und steuern"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Die Funktion kann alle Inhalte auf dem Bildschirm lesen und diese Inhalte über anderen Apps anzeigen."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Aktionen aufrufen und durchführen"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Die Funktion kann deine Interaktionen mit einer App oder einem Hardwaresensor verfolgen und in deinem Namen mit Apps interagieren."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Zulassen"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Ablehnen"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Beenden"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Abbrechen"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"<xliff:g id="SERVICE">%1$s</xliff:g> beenden?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Wenn du auf \"<xliff:g id="STOP">%1$s</xliff:g>\" tippst, wird \"<xliff:g id="SERVICE">%2$s</xliff:g>\" beendet."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Keine Dienste installiert"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Kein Dienst ausgewählt"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Es wurde keine Beschreibung bereitgestellt."</string>
    <string name="settings_button" msgid="2195468788019730377">"Einstellungen"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"Lichtempfindlichkeit, Photophobie, dunkles Design, Migräne, Kopfschmerzen, Lesemodus, Nachtmodus, Helligkeit verringern, Weißpunkt"</string>
    <string name="keywords_accessibility" msgid="4263443239404659143">"Einfache Verwendung, einfacher Zugriff, Unterstützung, unterstützend"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Fenstervergrößerung, Zoom, Vergrößerung, eingeschränktes Sehvermögen, Vergrößerung, größer machen"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Untertitel, Automatische Transkription, Schwerhörigkeit, Hörverlust, Spracherkennung in Echtzeit (CART), Spracherkennung"</string>
    <string name="keywords_live_transcribe" msgid="3226990195174890997"></string>
    <string name="keywords_sound_notifications" msgid="8183107485754075413"></string>
    <string name="keywords_sound_amplifier" msgid="939404835256246663"></string>
    <string name="keywords_display_size" msgid="5286419615221231518">"Displaygröße, großer Bildschirm"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Hoher Kontrast, eingeschränktes Sehvermögen, Fettschrift, Fettdruck"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"Farbe anpassen"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"Display dunkel machen, Display hell machen"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"Farbkontrast"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="7151756353013736931">"Motorik, Maus"</string>
    <string name="keywords_hearing_aids" msgid="4550504337687223314">"Hörgeräte, schwerhörig, Hörverlust, Cochlea-Implantate, Audioverstärker, Geräuschprozessor"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"Schwerhörigkeit, Hörverlust, Untertitel, Fernschreiber, TTY"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="print_settings" msgid="8519810615863882491">"Drucken"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Aus"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 Druckdienst aktiviert}other{# Druckdienste aktiviert}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 Druckauftrag}other{# Druckaufträge}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Druckdienste"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Keine Dienste installiert"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Keine Drucker gefunden"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Einstellungen"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Drucker hinzufügen"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"An"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Aus"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Dienst hinzufügen"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Drucker hinzufügen"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Suchen"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Nach Druckern suchen..."</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Dienst deaktiviert"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Druckaufträge"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Druckauftrag"</string>
    <string name="print_restart" msgid="4424096106141083945">"Neu starten"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Abbrechen"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="2887013172492183045">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> wird konfiguriert"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> wird gedruckt"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> wird abgebrochen..."</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Druckerfehler <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Drucker hat <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> blockiert."</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Suchfeld angezeigt"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Suchfeld ausgeblendet"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Weitere Informationen über diesen Drucker"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Akku"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Was zum Akkuverbrauch beiträgt"</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"Noch <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"Verbleibende Ladezeit: <xliff:g id="UNTIL_CHARGED">%1$s</xliff:g>"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Niedriger Akkustand"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"App darf im Hintergrund ausgeführt werden"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Hintergrundaktivität einschränken?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Wenn du die Hintergrundaktivität einer App einschränkst, kann dies zu unerwünschtem Verhalten führen"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Da bei dieser App die Akkunutzung nicht optimiert wird, kannst du sie nicht einschränken.\n\nDu musst du zunächst die Akkuoptimierung aktivieren."</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Uneingeschränkt"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimiert"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Eingeschränkt"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Akkunutzung im Hintergrund ohne Einschränkungen erlauben. Dadurch kann sich der Akkuverbrauch erhöhen."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Auf Grundlage deiner Nutzung optimieren. Für die meisten Apps empfohlen."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Akkunutzung im Hintergrund einschränken. Die App funktioniert dann möglicherweise nicht wie erwartet. Benachrichtigungen können verzögert ankommen."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Änderungen der Akkunutzung einer App kann Auswirkungen auf die Leistung der App haben."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Diese App benötigt <xliff:g id="STATE">%1$s</xliff:g> Akkunutzung."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"uneingeschränkte"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimierte"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Weitere Informationen zu den Akkunutzungsoptionen"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Displaynutzung seit letzter vollständiger Aufladung"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Akkunutzung"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Verlaufsdetails"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Akkunutzung"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Nutzung der letzten 24 Stunden abrufen"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Nutzung seit letztem kompletten Aufladen"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Akkunutzung der App"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Details"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Energieverbrauch anpassen"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Enthaltene Pakete"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Apps funktionieren normal"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Akkustand niedrig"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Energiesparmodus aktivieren, um Akkulaufzeit zu erhöhen"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Akkulaufzeit optimieren"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Funktion \"Akku-Manager\" aktivieren"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Energiesparmodus aktivieren"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Der Akku könnte früher als üblich leer sein"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Energiesparmodus an"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Weitere Informationen zum Energiesparmodus"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Einige Funktionen sind eventuell eingeschränkt"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Höhere Akkunutzung"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Apps mit der höchsten Nutzung anzeigen"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Zur Schonung deines Akkus wird er im optimierten Modus geladen"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Der Akku wird im optimierten Modus geladen, um ihn zu schonen"</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"Zur Schonung deines Akkus wird er im optimierten Modus geladen"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"Wenn sich das Gerät im Dock befindet, wird der Akku im optimierten Modus geladen, um ihn zu schonen"</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"Zur Schonung deines Akkus wird er im optimierten Modus geladen"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"Wenn sich das Gerät im Dock befindet, wird der Akku im optimierten Modus geladen, um ihn zu schonen"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"Vollständig aufladen"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"Zur Schonung deines Akkus wird er im optimierten Modus geladen, wenn sich dein Tablet das nächste Mal im Dock befindet"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Weitere Informationen zum pausierten Ladevorgang"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Ladevorgang fortsetzen"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Umfasst Hintergrundaktivitäten mit hohem Stromverbrauch"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{# App einschränken}other{# Apps einschränken}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} wurde kürzlich eingeschränkt}other{# Apps wurden kürzlich eingeschränkt}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} hat eine hohe Akkunutzung im Hintergrund}other{# Apps haben eine hohe Akkunutzung im Hintergrund}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Diese App kann nicht im Hintergrund ausgeführt werden}other{Diese Apps können nicht im Hintergrund ausgeführt werden}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{App einschränken?}other{# Apps einschränken?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Um den Akku zu schonen, kannst du verhindern, dass <xliff:g id="APP">%1$s</xliff:g> im Hintergrund Strom verbraucht. Eventuell funktioniert die App dann nicht mehr richtig und Benachrichtigungen werden verzögert angezeigt."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Um den Akku zu schonen, kannst du verhindern, dass diese Apps im Hintergrund Strom verbrauchen. Eventuell funktionieren sie dann nicht mehr richtig und Benachrichtigungen werden verzögert angezeigt.\n\nApps:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Um den Akku zu schonen, kannst du verhindern, dass diese Apps im Hintergrund Strom verbrauchen. Eventuell funktionieren sie dann nicht mehr richtig und Benachrichtigungen werden verzögert angezeigt.\n\nApps:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Einschränken"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Beschränkung entfernen?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Diese App kann dann im Hintergrund laufen und beansprucht dabei den Akku. Er könnte deshalb früher als erwartet leer sein."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Entfernen"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Abbrechen"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Vollständig aufladen"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Problem mit dem Ladezubehör"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Weitere Informationen zu nicht kompatiblen Ladegräten"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Akku-Manager"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Apps automatisch verwalten"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Wenn die Funktion \"Akku-Manager\" Apps mit hohem Akkuverbrauch erkennt, hast du die Möglichkeit, diese Apps einzuschränken. Eventuell funktionieren sie dann nicht mehr richtig und Benachrichtigungen werden verzögert angezeigt."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Eingeschränkte Apps"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Akkunutzung für # App einschränken}other{Akkunutzung für # Apps einschränken}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"<xliff:g id="TIME">%1$s</xliff:g> eingeschränkt"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Diese Apps verbrauchen keinen Akku im Hintergrund. Eventuell funktionieren sie nicht wie erwartet und Benachrichtigungen werden verzögert angezeigt."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Funktion \"Akku-Manager\" verwenden"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Starke Beanspruchung des Akkus durch Apps erkennen"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Erkennen, wenn Apps den Akku beanspruchen"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Erkennen, wenn Apps den Akku beanspruchen"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# App eingeschränkt}other{# Apps eingeschränkt}}"</string>
    <string name="battery_header_title_alternate" msgid="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="battery_missing_message" msgid="400958471814422770">"Problem beim Lesen des Akkustands."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Tippe, um mehr über diesen Fehler zu erfahren"</string>
    <string name="power_screen" msgid="4596900105850963806">"Display"</string>
    <string name="power_cpu" msgid="1820472721627148746">"CPU"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Taschenlampe"</string>
    <string name="power_camera" msgid="4778315081581293923">"Kamera"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"WLAN"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Mobilfunknetz"</string>
    <string name="power_phone" msgid="2768396619208561670">"Anrufe"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Displaynutzung: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> durch <xliff:g id="APP">%2$s</xliff:g> verbraucht"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> des gesamten Akkuverbrauchs"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Verbrauchsdetails seit letztem kompletten Aufladen"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Letztes komplettes Aufladen"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Ungefähre Nutzungsdauer bei vollständiger Aufladung"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Die verbleibende Akkulaufzeit ist eine Schätzung und kann sich je nach Nutzung ändern"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Akkunutzung"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Keine Nutzung seit der letzten vollständigen Aufladung"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Keine Nutzung in den letzten 24 Stunden"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"seit dem letzten kompletten Aufladen"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"System-Apps"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Sonstige"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Geschätzte verbleibende Akkulaufzeit"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Bis zur vollständigen Aufladung"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Schätzung kann sich je nach Nutzung ändern"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Mediaserver"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"App-Optimierung"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Tethering"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Entfernte Apps"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Energiesparmodus"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Automatisch aktivieren"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Keine Aktivierung nach Zeitplan"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Aktivierung gemäß deiner Gewohnheiten"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Wird gemäß meiner Gewohnheiten aktiviert"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Aktivierung gemäß festgelegtem Akkustand"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Der Energiesparmodus wird automatisch aktiviert, wenn der Akku wahrscheinlich nicht bis zum nächsten Aufladen hält (ermittelt anhand deines üblichen Aufladezeitpunkts)."</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Wird bei <xliff:g id="PERCENT">%1$s</xliff:g> aktiviert"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Zeitplan festlegen"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Akkulaufzeit verlängern"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Bei vollem Akku ausschalten"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Deaktivieren ab <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Der Energiesparmodus wird deaktiviert, wenn der Akku <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> erreicht"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Aktivieren"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Energiesparmodus aktivieren"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Automatisch aktivieren"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nie"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"bei <xliff:g id="PERCENT">%1$s</xliff:g> Akku"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Ladestandanzeige in Prozent"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Ladestand in Statusleiste in Prozent anzeigen"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Akkustand seit dem letzten kompletten Aufladen"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Akkustand während der letzten 24 Stunden"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"App-Verbrauch seit letztem vollständigen Aufladen"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"App-Nutzung während der letzten 24 Stunden"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Systemverbrauch seit dem letzten kompletten Aufladen"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Systemnutzung während der letzten 24 Stunden"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Systemnutzung im Zeitraum <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"App-Nutzung im Zeitraum <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Systemnutzung von letzter vollständiger Aufladung bis <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"App-Nutzung von letzter vollständiger Aufladung bis <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Gesamt: weniger als eine Minute"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Hintergrund: weniger als eine Minute"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Bildschirmzeit: weniger als eine Minute"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Gesamt: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Hintergrund: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Bildschirmzeit: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Sobald das Gerät vollständig geladen ist, sind Daten zur Akkunutzung in einigen Stunden verfügbar"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"jetzt"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"von <xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g> bis <xliff:g id="TO_TIMESTAMP">%2$s</xliff:g>"</string>
    <string name="battery_usage_day_and_hour" msgid="1417890420844950881">"<xliff:g id="DAY">%1$s</xliff:g> <xliff:g id="HOUR">%2$s</xliff:g>"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Diagramm zur Akkunutzung"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Diagramm zur täglichen Akkunutzung"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Diagramm zur stündlichen Akkunutzung"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Akkunutzung seit dem letzten kompletten Aufladen"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Akkunutzung von <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Bildschirmzeit seit dem letzten kompletten Aufladen"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Bildschirmzeit von <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Nach Apps filtern"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Nach Systemen filtern"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Prozessstatistiken"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Statistiken zu laufenden Prozessen"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Arbeitsspeichernutzung"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> von <xliff:g id="TOTALRAM">%2$s</xliff:g> genutzt in der letzten Zeit (<xliff:g id="TIMEDURATION">%3$s</xliff:g>)"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="PERCENT">%1$s</xliff:g> RAM genutzt in <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Hintergrund"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Vordergrund"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Im Cache"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Android-Betriebssystem"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Nativ"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Kernel"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-RAM"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Caches"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"RAM-Nutzung"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"RAM-Nutzung (Hintergrund)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Laufzeit"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Prozesse"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Dienste"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Dauer"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Speicherdetails"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 Stunden"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 Stunden"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 Stunden"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 Tag"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"System-Apps anzeigen"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"System-Apps ausblenden"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Prozentangaben anzeigen"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"USS verwenden"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Statistiktyp"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Hintergrund"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Vordergrund"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Im Cache"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Spracheingabe&amp;-ausgabe"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Einstellungen für Spracheingabe &amp; -ausgabe"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Sprachsuche"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Android-Tastatur"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Einstellungen für Spracheingabe"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Spracheingabe"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Spracheingabedienste"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Vollständiger Sprachinteraktionsdienst einschließlich der Verwendung von Hotwords"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Einfache Sprachausgabe-Funktion"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Dieser Spracheingabedienst kann Spracheingaben jederzeit überwachen und Anwendungen, die Sprachbefehle unterstützen, für dich steuern. Er wird von der Anwendung <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g> bereitgestellt. Möchtest du diesen Dienst aktivieren?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Einstellungen für Erkennung auf dem Gerät"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Spracherkennung auf dem Gerät"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Spracherkennung auf dem Gerät"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Bevorzugtes Modul"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Moduleinstellungen"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Sprechgeschwindigkeit &amp; Stimmlage"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Modul"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Stimmen"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Gesprochene Sprache"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Stimmen installieren"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"App \"<xliff:g id="TTS_APP_NAME">%s</xliff:g>\" öffnen, um Stimmen zu installieren"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"App öffnen"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Abbrechen"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Zurücksetzen"</string>
    <string name="tts_play" msgid="2945513377250757221">"Wiedergeben"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Nicht sicher"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> ist nicht sicher"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> sind nicht sicher"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Adaptive Konnektivität"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Verlängert die Akkulaufzeit und optimiert die Leistung des Geräts durch automatisches Verwalten deiner Netzwerkverbindungen"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"An"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Aus"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Adaptive Konnektivität verwenden"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Anmeldedatenspeicher"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Ein Zertifikat installieren"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Anmeldedaten löschen"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Alle Zertifikate entfernen"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Vertrauenswürdige Anmeldedaten"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Vertrauenswürdige CA-Zertifikate anzeigen"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Nutzeranmeldedaten"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Gespeicherte Anmeldedaten anzeigen und ändern"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Erweitert"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Anmeldedaten sind für diesen Nutzer nicht verfügbar."</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Installiert für VPN und Apps"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Installiert für WLAN"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Installiert für WLAN (wird gerade verwendet)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Alle Inhalte entfernen?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Speicher wurde gelöscht."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Anmeldedaten nicht gelöscht"</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Apps mit Nutzungsdatenzugriff"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA-Zertifikat"</string>
    <string name="user_certificate" msgid="6897024598058566466">"VPN- &amp; App-Nutzerzertifikat"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"WLAN-Zertifikat"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Deine Daten werden nicht geschützt"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"CA-Zertifikate werden von Websites, Apps und VPNs zur Verschlüsselung verwendet. Du solltest nur CA-Zertifikate von Organisationen installieren, denen du vertraust. \n\nWenn du ein CA-Zertifikat installierst, hat dessen Inhaber Zugriff auf deine Daten, z. B. auf Passwörter oder Kreditkartendetails von Websites, die du besuchst, oder von Apps, die du verwendest. Das ist auch dann der Fall, wenn diese Daten verschlüsselt sind."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Nicht installieren"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Trotzdem installieren"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Zertifikat nicht installiert"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Darf "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" Zertifikate auf diesem Gerät installieren?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Diese Zertifikate überprüfen deine Identität, indem sie die individuelle ID deines Geräts mit den folgenden Apps und URLs teilen"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Nicht zulassen"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Zulassen"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Mehr anzeigen"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Zertifikatsver­waltungs-App"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Keine"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Mit Zertifikaten wird deine Identität überprüft, wenn du die folgenden Apps und URLs verwendest"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Zertifikate deinstallieren"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"App entfernen"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Diese App entfernen?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Mit dieser App werden keine Zertifikate mehr verwaltet, aber sie verbleibt auf deinem Gerät. Alle Zertifikate, die von der App installiert wurden, werden deinstalliert."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}other{# URLs}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Notrufsignal"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Verhalten bei einem Notruf festlegen"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Sicherung"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"An"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Aus"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Sicherung &amp; Wiederherstellung"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Personenbezogene Daten"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Meine Daten sichern"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"App-Daten, WLAN-Passwörter und andere Einstellungen auf Google-Servern sichern"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Sicherungskonto"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Sicherungskonto verwalten"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"App-Daten einschließen"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automatische Wiederherstellung"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Nach der Neuinstallation einer App werden gesicherte Einstellungen und Daten automatisch wiederhergestellt"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Sicherungsdienst ist nicht aktiv"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Zurzeit werden in keinem Konto gesicherte Daten gespeichert."</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Sicherung deiner WLAN-Passwörter, Lesezeichen, anderer Einstellungen und App-Daten beenden und alle Kopien auf Google-Servern löschen?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Soll das Sichern von Gerätedaten, wie z. B WLAN-Passwörtern und Anrufliste, sowie App-Daten, wie z. B. Einstellungen und von Apps gespeicherten Dateien, beendet werden und sollen alle Kopien auf Remote-Servern gelöscht werden?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Automatische Fernsicherung von Gerätedaten wie WLAN-Passwörtern und Anrufliste und App-Daten, z. B. Einstellungen und von Apps gespeicherte Dateien\n\nWenn du die automatische Sicherung aktivierst, werden Geräte- und App-Daten regelmäßig aus der Ferne gespeichert. Bei App-Daten kann es sich um alle Daten handeln, die von einer App entsprechend den Entwicklereinstellungen gespeichert wurden, einschließlich potenziell sensibler Daten wie Kontakten, Nachrichten und Fotos."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Geräteadministrator-Einstellungen"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"App zur Geräteverwaltung"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Diese App zur Geräteverwaltung deaktivieren"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"App deinstallieren"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Deaktivieren &amp; deinstallieren"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Apps zur Geräteverwaltung"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Keine App zur Geräteverwaltung verfügbar"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Keine verfügbaren Trust Agents"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"App zur Geräteverwaltung aktivieren?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Diese App zur Geräteverwaltung aktivieren"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Geräteadministrator"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Wenn diese App zur Geräteverwaltung aktiviert ist, kann die App „<xliff:g id="APP_NAME">%1$s</xliff:g>“ Folgendes tun:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Dieses Gerät wird von <xliff:g id="APP_NAME">%1$s</xliff:g> verwaltet und überwacht."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Diese App zur Geräteverwaltung ist aktiv, sodass die App „<xliff:g id="APP_NAME">%1$s</xliff:g>“ Folgendes tun kann:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Profilverwaltung aktivieren?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Elternaufsicht zulassen?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Der Nutzer wird vom gewählten Administrator verwaltet, wenn fortgefahren wird. Dieser kann dann möglicherweise zusätzlich zu den personenbezogenen Daten auch damit verbundene Daten speichern.\n\nDer Administrator kann die mit diesem Nutzer verbundenen Einstellungen, Zugriffsrechte, Apps und Daten überwachen und verwalten, einschließlich der Netzwerkaktivitäten und der Standortinformationen des Geräts."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Andere Optionen wurden von deinem Administrator deaktiviert"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Weitere Informationen"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Benachrichtigungsprotokoll"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Benachrichtigungs­verlauf"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Letzte %d Stunden"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Im Schlummermodus"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Kürzlich geschlossen"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# Be­nach­rich­ti­gung}other{# Be­nach­rich­ti­gun­gen}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Klingelton &amp; Vibration für Anrufe"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Netzwerkdetails"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Synchronisierung aktiviert"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Synchronisierung deaktiviert"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Synchronisierung läuft"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Synchronisierungsfehler"</string>
    <string name="sync_failed" msgid="3806495232114684984">"Fehler bei der Synchronisierung"</string>
    <string name="sync_active" msgid="5787407579281739975">"Synchronisierung aktiv"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Synchronisierung"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Bei der Synchronisierung treten momentan Probleme auf. Sie wird in Kürze fortgesetzt."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Konto hinzufügen"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Arbeitsprofil ist noch nicht verfügbar."</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Geschäftliche Apps"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Arbeitsprofil entfernen"</string>
    <string name="background_data" msgid="321903213000101158">"Hintergrunddaten"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Daten können jederzeit synchronisiert, gesendet und empfangen werden."</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Hintergrunddaten deaktivieren?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Durch die Deaktivierung von Hintergrunddaten kann die Akkulaufzeit verlängert und die Verwendung von Daten verringert werden. Einige Apps nutzen die Hintergrunddatenverbindung eventuell weiterhin."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Synchronisierung: AN"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Synchronisierung: AUS"</string>
    <string name="sync_error" msgid="846923369794727644">"Synchronisierungsfehler"</string>
    <string name="last_synced" msgid="1527008461298110443">"Zuletzt synchronisiert: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Wird synchronisiert…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Einstellungen sichern"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Meine Einstellungen sichern"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Jetzt synchronisieren"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Synchronisierung abbrechen"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Tippen, um jetzt zu synchronisieren<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Google Kalender"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontakte"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Einstellungen für die App-Synchronisierung"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Daten &amp; Synchronisierung"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Passwort ändern"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Kontoeinstellungen"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Konto entfernen"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Konto hinzufügen"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Konto entfernen?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Dein Administrator lässt diese Änderung nicht zu"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Manuelle Synchronisierung nicht möglich"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Die Synchronisierung hierfür ist deaktiviert. Zur Änderung dieser Einstellung aktiviere vorübergehend die Hintergrunddaten und die automatische Synchronisierung."</string>
    <string name="delete" msgid="8330605554706263775">"Löschen"</string>
    <string name="select_all" msgid="7898929601615536401">"Alles auswählen"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Datennutzung"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobile Daten und WLAN"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Private Daten autom. synchronisieren"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Arbeitsdaten autom. synchronisieren"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Zyklus ändern..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Tag, an dem Datenverbrauchszyklus zurückgesetzt wird:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Kein Datenverbrauch in diesem Zeitraum"</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Vordergrund"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Hintergrund"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"Eingeschränkt"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Mobile Daten deaktivieren?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Limit festlegen"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"4G-Datenlimit festlegen"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"2G-/3G-Datenlimit festlegen"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"WLAN-Datenlimit festlegen"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"WLAN"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobil"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G/3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Mobil"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Keine"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobile Daten"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"2G-/3G-Daten"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"4G-Daten"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Vordergrund:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Hintergrund:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"App-Einstellungen"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Hintergrunddaten"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Mobile Datennutzung im Hintergrund aktivieren"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Lege zur Beschränkung der App-Hintergrunddaten zuerst ein Mobildatenlimit fest."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Hintergrunddaten beschränken?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Diese Funktion kann dazu führen, dass eine auf Hintergrunddaten basierende App nicht mehr funktioniert, wenn nur Mobilfunknetze verfügbar sind.\n\nGeeignetere Kontrollmechanismen für den Datenverbrauch findest du in den Einstellungen der App."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Hintergrunddaten können nur eingeschränkt werden, wenn du ein Limit für mobile Daten festgelegt hast."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Automatische Synchronisierung aktivieren?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Automatische Synchronisierung deaktivieren?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"So reduzierst du den Datenverbrauch und schonst den Akku, musst jedoch jedes einzelne Konto manuell synchronisieren, um neue Informationen abzurufen. Außerdem erhältst du keine Benachrichtigungen, wenn Aktualisierungen erfolgen."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Tag für Zurücksetzung des Nutzungszyklus"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Jeden Monat zurücksetzen am:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Übernehmen"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Warnung für Datenverbrauch festlegen"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Datenlimit festlegen"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Datennutzung begrenzen"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g> "</font><font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"Warnung"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font><font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"Limit"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Entfernte Apps"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Entfernte Apps und Nutzer"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Netzwerknutzung"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Kostenpflichtig"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Name"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Typ"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Serveradresse"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"PPP-Verschlüsselung (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"L2TP-Schlüssel"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"IPSec-ID"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Vorinstallierter IPSec-Schlüssel"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"IPSec-Nutzerzertifikat"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"IPSec-CA-Zertifikat"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"IPSec-Serverzertifikat"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Erweiterte Optionen anzeigen"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"DNS-Suchdomains"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"DNS-Server (z. B. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Weiterleitungsrouten (z. B. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Nutzername"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Passwort"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Kontoinformationen speichern"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(nicht verwendet)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(Server nicht überprüfen)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(vom Server erhalten)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Dieser VPN-Typ kann nicht durchgehend verbunden bleiben"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"Durchgehend aktives VPN unterstützt numerische Serveradressen"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"Ein DNS-Server muss für durchgehend aktives VPN angegeben werden"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"DNS-Serveradressen müssen für durchgehend aktives VPN numerisch sein"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Bei den eingegebenen Informationen wird durchgehend aktives VPN nicht unterstützt"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Abbrechen"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Schließen"</string>
    <string name="vpn_save" msgid="683868204634860888">"Speichern"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Verbinden"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Ersetzen"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"VPN-Profil bearbeiten"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Entfernen"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Mit <xliff:g id="PROFILE">%s</xliff:g> verbinden"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Verbindung zu diesem VPN trennen?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Verbindung trennen"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Version"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"VPN entfernen"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Aktuelles VPN ersetzen?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Durchgehend aktives VPN aktivieren?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Wenn diese Einstellung aktiviert ist, wird nur dann eine Internetverbindung hergestellt, wenn eine VPN-Verbindung besteht"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Dein aktuelles VPN wird ersetzt und die Internetverbindung wird nur dann hergestellt, wenn eine VPN-Verbindung besteht"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Du bist schon mit einem durchgehend aktiven VPN verbunden. Wenn du eine Verbindung mit einem anderen VPN herstellst, wird dein aktuelles ersetzt und der Modus \"Durchgehend aktives VPN\" wird deaktiviert."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Du bist schon mit einem VPN verbunden. Wenn du eine Verbindung mit einem anderen VPN herstellst, wird dein aktuelles ersetzt."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Aktivieren"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"Verbindung zu <xliff:g id="VPN_NAME">%1$s</xliff:g> kann nicht hergestellt werden"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Bei dieser App wird durchgehend aktives VPN nicht unterstützt"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"VPN-Profil hinzufügen"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Profil bearbeiten"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Profil löschen"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Durchgehend aktives VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Keine VPNs hinzugefügt"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Verbindung zu VPN immer beibehalten"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Von dieser App nicht unterstützt"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Immer aktiviert"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Nicht sicher"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Verbindungen ohne VPN blockieren"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"VPN-Verbindung erforderlich?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Unsicher. Update auf IKEv2-VPN empfohlen."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Wähle ein VPN-Profil für eine durchgehende Verbindung aus. Netzwerkverkehr ist nur möglich, wenn eine Verbindung zu diesem VPN besteht."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Keines"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Für ein durchgehend aktives VPN ist eine IP-Adresse für den Server und für das DNS erforderlich."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Es ist keine Netzwerkverbindung verfügbar. Bitte versuche es später noch einmal."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Verbindung mit VPN getrennt"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Kein VPN"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Ein Zertifikat fehlt. Versuche, das Profil zu ändern."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"System"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Nutzer"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Deaktivieren"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Aktivieren"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Deinstallieren"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Vertrauen"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"System-CA-Zertifikat aktivieren?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"System-CA-Zertifikat deaktivieren?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"CA-Zertifikat des Nutzers endgültig entfernen?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Wird verwendet von"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Dieser Eintrag beinhaltet"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 Nutzerschlüssel"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 Nutzerzertifikat"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 CA-Zertifikat"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA-Zertifikate"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Details für Anmeldedaten"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Anmeldedaten entfernt: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Keine Nutzeranmeldedaten installiert"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Rechtschreibprüfung"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Rechtschreibprüfung für die Arbeit"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Aktuelles Passwort für vollständige Sicherungen eingeben"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Neues Passwort für vollständige Sicherungen eingeben"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Neues Passwort für vollständige Sicherungen erneut eingeben"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Passwort festlegen"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Abbrechen"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Zusätzliche Systemupdates"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Das Netzwerk wird eventuell überwacht."</string>
    <string name="done_button" msgid="6269449526248267">"Fertig"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Dem Zertifikat vertrauen oder es entfernen}other{Den Zertifikaten vertrauen oder sie entfernen}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} hat eine Zertifizierungsstelle auf deinem Gerät installiert. Damit können die Netzwerkaktivitäten deines Geräts überwacht werden, einschließlich E-Mails, Apps und sicherer Websites.\n\nWeitere Informationen zu diesem Zertifikat erhältst du von deinem Administrator.}other{{orgName} hat Zertifizierungsstellen auf deinem Gerät installiert. Damit können die Netzwerkaktivitäten deines Geräts überwacht werden, einschließlich E-Mails, Apps und sicherer Websites.\n\nWeitere Informationen zu diesen Zertifikaten erhältst du von deinem Administrator.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} hat eine Zertifizierungsstelle für dein Arbeitsprofil installiert. Damit können deine geschäftlichen Netzwerkaktivitäten überwacht werden, einschließlich E-Mails, Apps und sicherer Websites.\n\nWeitere Informationen zu diesem Zertifikat erhältst du von deinem Administrator.}other{{orgName} hat Zertifizierungsstellen für dein Arbeitsprofil installiert. Damit können deine geschäftlichen Netzwerkaktivitäten überwacht werden, einschließlich E-Mails, Apps und sicherer Websites.\n\nWeitere Informationen zu diesen Zertifikaten erhältst du von deinem Administrator.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Dritte können deine Netzwerkaktivitäten überwachen, einschließlich E-Mails, Apps und sicherer Websites.\n\nDies wird durch vertrauenswürdige Anmeldedaten ermöglicht, die auf deinem Gerät installiert sind."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Zertifikat prüfen}other{Zertifikate prüfen}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Mehrere Nutzer"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Nutzer &amp; Profile"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Nutzer oder Profil hinzufügen"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Eingeschränktes Profil"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Nicht eingerichtet"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Eingeschränktes Profil nicht eingerichtet"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Nicht eingerichtet – Arbeitsprofil"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administrator"</string>
    <string name="user_you" msgid="3070562015202859996">"Ich (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Du kannst keine weiteren Nutzer hinzufügen. Entferne dazu zuerst einen bisherigen Nutzer."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"In eingeschränkten Profilen können keine Konten hinzugefügt werden."</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"<xliff:g id="USER_NAME">%1$s</xliff:g> vom Gerät löschen"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Einstellungen für den Sperrbildschirm"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Nutzer vom Sperrbildschirm aus hinzufügen"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Zu Administrator wechseln, wenn angedockt"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Dich selbst löschen?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Diesen Nutzer löschen?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Dieses Profil entfernen?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Arbeitsprofil entfernen?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Sämtliche Apps und Daten werden gelöscht."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Wenn du den Vorgang fortsetzt, werden alle Apps und Daten in diesem Profil gelöscht."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Sämtliche Apps und Daten werden gelöscht."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Neuer Nutzer wird hinzugefügt…"</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Nutzer löschen"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Löschen"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Alle Apps und Daten in dieser Sitzung werden gelöscht."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Entfernen"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Gast (ich)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Nutzer"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Andere Nutzer"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Gastaktivität löschen"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Beim Beenden des Gastmodus alle Gastdaten und -Apps löschen"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Gastaktivität löschen?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Apps und Daten dieser Gastsitzung werden jetzt gelöscht und alle künftigen Gastaktivitäten werden jeweils beim Beenden des Gastmodus gelöscht"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"löschen, gast, aktivität, entfernen, daten, besucher, löschen"</string>
    <string name="enable_guest_calling" msgid="8300355036005240911">"Gast Nutzung von Telefon erlauben"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Gastnutzer kann auf Anrufliste zugreifen"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Telefonieren &amp; SMS zulassen"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Diesen Nutzer als Administrator festlegen"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Nutzer löschen"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Telefonieren &amp; SMS zulassen?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Anrufliste und SMS-Verlauf werden für diesen Nutzer freigegeben."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Administratorberechtigungen widerrufen?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Wenn du die Administratorberechtigungen für diesen Nutzer entfernst, können sie von dir oder einem anderen Administrator später wiederhergestellt werden."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Notfallinformationen"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Informationen und Kontaktdaten für <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"„<xliff:g id="APP_NAME">%1$s</xliff:g>“ öffnen"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Apps und Inhalte zulassen"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Apps mit Einschränkungen"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"App-Einstellungen erweitern"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Apps zum Installieren auswählen"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Verfügbare Apps installieren"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Kontaktloses Bezahlen"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Standard-Zahlungs-App"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Wenn du über eine Zahlungs-App zahlen möchtest, halte die Rückseite deines Geräts ans Zahlungsterminal"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Weitere Informationen"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Geschäft­liche App als Stan­dard-Zah­lungs-App fest­legen?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"So zahlst du über eine geschäftliche App:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"Das Arbeitsprofil muss aktiviert sein."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"Du musst PIN, Muster oder Passwort des Arbeitsprofils eingeben, falls vorhanden."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Funktionsweise"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Mit deinem Smartphone in Geschäften bezahlen"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Standard-App für Zahlungen"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Nicht festgelegt"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g> – <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="6127665705799658860">"Standard-Zahlungs-App verwenden"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Standard-Zahlungs-App verwenden"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Immer"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Außer wenn eine andere Zahlungs-App geöffnet ist"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"An einem Terminal für kontaktloses Bezahlen folgende App nutzen:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Am Terminal bezahlen"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Richte eine Zahlungs-App ein. Anschließend kannst du kontaktlos bezahlen, indem du die Rückseite deines Smartphones an ein Terminal mit dem entsprechenden Symbol hältst."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Ok"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Mehr…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Standard-App für kontaktloses Bezahlen festlegen"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Standard-App für kontaktloses Bezahlen aktualisieren"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"An einem Terminal für kontaktloses Bezahlen <xliff:g id="APP">%1$s</xliff:g> nutzen"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"An einem Terminal für kontaktloses Bezahlen <xliff:g id="APP_0">%1$s</xliff:g> nutzen.\n\nDadurch wird <xliff:g id="APP_1">%2$s</xliff:g> als Ihre Standard-App für das kontaktlose Bezahlen ersetzt."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Standard festlegen"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Aktualisieren"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Geschäftlich"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Einschränkungen"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Einschränkungen aufheben"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"PIN ändern"</string>
    <string name="help_label" msgid="2896538416436125883">"Hilfe &amp; Feedback"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Konto für Inhalte"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"Foto-ID"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Extreme Gefahren"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Warnungen zu extremen Gefahren für Leben und Eigentum erhalten"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Erhebliche Gefahren"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Warnungen zu erheblichen Gefahren für Leben und Eigentum erhalten"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"AMBER Alerts"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Bulletins über Kindesentführungen erhalten"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Wiederholen"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Anrufverwaltung aktivieren"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Diesem Dienst die Verwaltung der Anrufabwicklung gestatten"</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Anrufverwaltung"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Notfall­benachrichtigungen an Mobilgeräte"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Netzbetreiber"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Zugangspunkte (APNs)"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Erweiterte Anruffunktionen"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"4G-Anrufe"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Zur Verbesserung von Sprachanrufen LTE-Dienste verwenden (empfohlen)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Zur Verbesserung von Sprachanrufen 4G-Dienste verwenden (empfohlen)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"5G für Sprachanrufe verwenden"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Kontakte an Mobilfunkanbieter senden"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Telefonnummern meiner Kontakte senden, um erweiterte Funktionen bereitzustellen"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Kontakte an <xliff:g id="CARRIER">%1$s</xliff:g> senden?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Kontakte an deinen Mobilfunkanbieter senden?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Die Telefonnummern deiner Kontakte werden regelmäßig an <xliff:g id="CARRIER">%1$s</xliff:g> gesendet.<xliff:g id="EMPTY_LINE">

</xliff:g>Anhand dieser Informationen kann festgestellt werden, ob deine Kontakte bestimmte Funktionen wie Videoanrufe oder einzelne Chatfunktionen verwenden können."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Die Telefonnummern deiner Kontakte werden regelmäßig an deinen Mobilfunkanbieter gesendet.<xliff:g id="EMPTY_LINE">

</xliff:g>Anhand dieser Informationen kann festgestellt werden, ob deine Kontakte bestimmte Funktionen wie Videoanrufe oder einzelne Chatfunktionen verwenden können."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Bevorzugter Netztyp"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (empfohlen)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"MMS"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Senden und empfangen, wenn mobile Daten deaktiviert sind"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Mobile Daten automatisch umschalten"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Dieses Netz verwenden, wenn es besseren Empfang bietet"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"SIM-Karte für Arbeit"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Zugriff auf Apps und Inhalte"</string>
    <string name="user_rename" msgid="8735940847878484249">"Umbenennen"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"App-Beschränkungen festlegen"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Von <xliff:g id="APP">%1$s</xliff:g> festgelegt"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Diese App darf auf deine Konten zugreifen."</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Diese App darf auf deine Konten zugreifen. Von <xliff:g id="APP">%1$s</xliff:g> festgelegt"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"WLAN und mobile Nutzung"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Änderungen an Einstellungen für WLAN und mobile Nutzung zulassen"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Änderungen an Bluetooth-Pairings und -Einstellungen zulassen"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Standort"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Apps die Verwendung deiner Standortinformationen gestatten"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Zurück"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Weiter"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Anders formatieren"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"SIMs"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Keine mobilen Daten verfügbar"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Tippen, um Daten-SIM auszuwählen"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Diese SIM für alle Anrufe verwenden"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"SIM für mobile Daten auswählen"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"SIM-Karte für SMS auswählen"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Daten-SIM wird gewechselt. Dies kann bis zu einer Minute dauern…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"<xliff:g id="NEW_SIM">%1$s</xliff:g> für mobile Daten nutzen?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Wenn du zu <xliff:g id="NEW_SIM">%1$s</xliff:g> wechselst, wird <xliff:g id="OLD_SIM">%2$s</xliff:g> nicht mehr für mobile Daten verwendet."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"<xliff:g id="NEW_SIM">%1$s</xliff:g> verwenden"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Anrufen mit"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Namen der SIM-Karte eingeben"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"SIM-Steckplatz %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Orange"</string>
    <string name="color_purple" msgid="6603701972079904843">"Lila"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Status der SIM-Karte"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"SIM-Status (SIM-Steckplatz %1$d)"</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="2819551384383504031">"SIMs geändert."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Zum Einrichten tippen"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Jedes Mal fragen"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Auswahl erforderlich"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"SIM-Auswahl"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Einstellungen"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Netzwerk und Internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobile Daten, WLAN, Hotspot"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"WLAN, Hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Verbundene Geräte"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, Kopplung"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, Fahrmodus, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, Fahrmodus"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, Fahrmodus, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, Fahrmodus"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"Nicht verfügbar, weil NFC deaktiviert ist"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Installiere zuerst eine Zahlungs-App, damit du die Option verwenden kannst"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Kürzlich geöffnete Apps, Standard-Apps"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Für Apps im Arbeitsprofil ist der Benachrichtigungszugriff nicht verfügbar."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Passwörter und Konten"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Gespeicherte Passwörter, Autofill, synchronisierte Konten"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Standard-Apps"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Geklonte Apps"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Du kannst eine zweite Instanz einer App erstellen, um zwei Konten gleichzeitig zu verwenden."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Apps, die geklont werden können."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"<xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g> geklont, <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g> können geklont werden"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Alle App-Klone löschen"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Löschen aller App-Klone fehlgeschlagen"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Wird erstellt…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Geklont"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Klon von <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> wird erstellt"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Klon von <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> erstellt"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Sprachen, Gesten, Zeit, Sicherung"</string>
    <string name="languages_setting_summary" msgid="7963053736715746726">"Systemsprachen, App-Sprachen, Spracheingabe"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wlan, wi-fi, netzwerkverbindung, internet, kabellos, daten, wifi, wi-fi, w-lan"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"WLAN-Benachrichtigung, WLAN-Benachrichtigung"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"Datennutzung"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"24-Stunden-Format verwenden"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Öffnen mit"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Anwendungen"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"Zeitzone"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Chat Head, System, Benachrichtigung, Fenster, Dialogfeld, einblenden, über anderen Apps, anzeigen"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Taschenlampe, Licht, Lampe"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wlan, umschalten, steuern"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobilfunk, mobil, mobilfunkanbieter, kabellos, drahtlos, daten, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wlan, anruf, anrufen, wlan-telefonie, anrufe über wlan"</string>
    <string name="keywords_display" msgid="874738809280751745">"bildschirm, display, touchscreen"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"display dimmen, touchscreen, akku, hell"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"display dimmen, nacht, farbton, night shift, helligkeit, displayfarbe, farbe, nachtmodus"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"hintergrund, personalisieren, display anpassen, bildschirm anpassen"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"textgröße"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"Projekt, Streaming, Display-Mirroring, Bildschirmfreigabe, Mirroring, freigegebener Bildschirm, Bildschirm-Streaming"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"speicherplatz, festplatte, gerätenutzung"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"akkuverbrauch, akkulaufzeit, aufladen"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"Akkunutzung anzeigen, Akkunutzung, Energieverbrauch"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"Energiesparmodus, Stromsparmodus, Sparmodus"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"Einstellungen für intelligenten Akku, intelligenter Akku"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"rechtschreibung, schreibweise, wörterbuch, rechtschreibprüfung, autokorrektur"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"spracherkennung, eingabe, sprache, sprechen, freisprechfunktion, erkennung, anstößig, wort, audio, verlauf, bluetooth headset"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"bewerten, sprache, standardeinstellung, standard, sprechen, tts, text in sprache, bedienungshilfen, screenreader, blind, sehbehindert"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"uhr, wecker, 24 stunden zählung"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"zurücksetzen, wiederherstellen, werkseinstellungen"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"wischen, löschen, wiederherstellen, entfernen, zurücksetzen auf werkseinstellungen"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"drucker"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"lautsprecher signalton, lautsprecher, lautstärke, stummschalten, audio, musik, haptik, vibration, vibrieren"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"bitte nicht stören, unterbrechen, unterbrechung, pause"</string>
    <string name="keywords_app" msgid="7983814237980258061">"ram"</string>
    <string name="keywords_location" msgid="8016374808099706213">"in der nähe, ort, standort, verlauf, berichterstellung, bericht erstellung, bericht erstellen, berichte erstellen, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"Konto, ein Konto hinzufügen, Arbeitsprofil, Konto hinzufügen, entfernen, löschen"</string>
    <string name="keywords_users" msgid="3497517660077620843">"einschränkung, einschränken, eingeschränkt"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"text korrektur, textkorrektur, korrigieren, sound, ton, vibrieren, automatisch, sprache, geste, touch-geste, vorschlagen, vorschlag, design, anstößig, wort, eingeben, emoji, international"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"zurücksetzen, einstellungen, standard, standardeinstellung"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"apps, download, anwendungen, system"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"apps, berechtigungen, sicherheit"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"apps, standard"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorieren, optimierungen, stromsparmodus, app standby"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"brillant, rgb, srgb, farbe, natürlich, standard"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, Auflösung, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"farbe, temperatur, d65, d73, weiß, gelb, blau, warm, kalt"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"zum entsperren über das display streichen, zum entsperren wischen, passwort, muster, pin"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"Bildschirmfixierung"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"herausforderung bei der arbeit, arbeit, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"arbeitsprofil, verwaltetes profil, gruppieren, gruppierung, arbeit, profil"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gesten, bewegungen, touch-gesten"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"Geldbörse"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"Bezahlen, kontaktlos, Zahlungen"</string>
    <string name="keywords_backup" msgid="707735920706667685">"Sicherung, sicherung"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"Touch-Geste"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"Gesicht, Entsperrung, Entsperrung per Gesichtserkennung, Gesichtserkennung, Anmeldung"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"Gesicht, entsperren, Authentifizierung, Anmeldung, Fingerabdruck, Biometrik"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, Min., prl version, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"netzwerk, status des mobilfunknetzes, status des dienstes, signalstärke, typ des mobilfunknetzes, roaming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"netzwerk, status des mobilfunknetzes, status des dienstes, signalstärke, typ des mobilfunknetzes, roaming"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"netzwerk, status des mobilfunknetzes, status des dienstes, signalstärke, typ des mobilfunknetzes, roaming, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"netzwerk, status des mobilfunknetzes, status des dienstes, signalstärke, typ des mobilfunknetzes, roaming, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"seriennummer, hardwareversion"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"stand der sicherheitsupdates android, baseband version, kernel version"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"Design, hell, dunkel, Modus, Lichtempfindlichkeit, Fotophobie, dunkler machen, abdunkeln, dunkler Modus, Migräne"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"Dunkles Design"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"Fehler"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Inaktivitätsdisplay, Sperrbildschirm"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"Sperrbildschirmbenachrichtigung, Benachrichtigungen"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"Gesicht"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"Fingerabdruck, Fingerabdruck hinzufügen"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"Gesicht, Fingerabdruck, Fingerabdruck hinzufügen"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"watch unlock, watch unlock hinzufügen"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"display dimmen, touchscreen, akku, intelligente helligkeit, dynamische helligkeit, automatische helligkeit"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"smart, display dimmen, ruhemodus, akku, zeitlimit, timeout, aufmerksamkeit, display, bildschirm, inaktivität"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"kamera, smart, automatisch drehen, automatisches drehen, drehen, spiegeln, drehung, hochformat, querformat, ausrichtung, vertikal, horizontal"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"upgrade, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"dnd, zeitplan, benachrichtigungen, blockieren, lautlos, vibrieren, schlaf, arbeit, fokus, ton, stumm, tag, wochentag, wochenende, wochenende, ereignis, bns"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"display, sperrzeit, timeout, lockscreen, bildschirm, zeitlimit, automatisch ausschalten"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"Speicher, Cache, Daten, löschen, entfernen, freigeben, Platz"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"verbunden, gerät, kopfhörer, headset, lautsprecher, drahtlos, koppeln, ohrhörer, musik, medien"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"Hintergrund, Design, Raster, anpassen, personalisieren"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"Symbol, Akzent, Farbe, Startbildschirm, Sperrbildschirm, Verknüpfung, Uhrgröße"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"standard, assistent"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"zahlung, standard"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"eingehende Benachrichtigung"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"usb tethering, bluetooth tethering, wlan hotspot, wifi hotspot"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"Haptik, haptisches Feedback, vibrieren, Vibration"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"haptik, vibrieren, display, empfindlichkeit"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"Haptik, vibrieren, Smartphone, Anruf, Empfindlichkeit, klingeln"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"Haptik, vibrieren, Smartphone, Anruf, klingeln lassen, schrittweise"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"haptik, haptisches feedback, vibrieren, empfindlichkeit, benachrichtigung"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"haptik, haptisches feedback, vibrieren, empfindlichkeit, alarm, wecker, weckruf"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"haptik, haptisches feedback, vibrieren, empfindlichkeit, medien"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"Haptik, vibrieren, Vibration"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"Energiesparmodus, fixiert, nichtflüchtig, Stromsparfunktion, Akku"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"ablauf, zeitplan, energiesparmodus, stromsparfunktion, akku, automatisch, prozent"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"VoLTE, erweiterte Anruffunktionen, 4G-Anrufe"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"Vo5g, VoNR, erweiterte Anruffunktionen, 5G-Anrufe"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"Sprache hinzufügen, eine Sprache hinzufügen"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"Textgröße, Großdruck, Großschrift, großer Text, eingeschränktes Sehvermögen, Text vergrößern, Textvergrößerung"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"immer aktiver Bildschirmschoner, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"NFC, Tag, Lesegerät"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Lautstärke, Vibration, Bitte nicht stören"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Medienlautstärke"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Streaminglautstärke"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Anruflautstärke"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Weckerlautstärke"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Lautstärke Klingeln/Benachrichtigungen"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Klingeltonlautstärke"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Benachrichtigungslautstärke"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Klingelton lautlos"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Klingeltonmodus „Vibration“"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Benachrichtigungen sind stummgeschaltet, Gerät vibriert bei Benachrichtigungen"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"<xliff:g id="VOLUME_TYPE">%1$s</xliff:g> stummgeschaltet"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Nicht verfügbar, da Klingelton stummgeschaltet ist"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Klingelton"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Standard-Benachrichtigungston"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Von App erzeugter Ton"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Standard-Benachrichtigungston"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Standard-Weckton"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Erst vibrieren, dann immer lauter klingeln"</string>
    <string name="spatial_audio_title" msgid="6591051622375191603">"Spatial Audio"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Wähltastentöne"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Ton bei Displaysperre"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Töne und Vibration beim Aufladen"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Docking-Sounds"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Töne bei Berührung"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Im Vibrationsmodus immer Symbol anzeigen"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Dock-Lautsprecherwiedergabe"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Alle Audioquellen"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Nur Medien-Audio"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Lautlos"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Töne"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibration"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Töne beim Hochfahren"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Automatische Untertitel"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Medien automatisch untertiteln"</string>
    <string name="spatial_audio_speaker" msgid="9145233652433523302">"Smartphone-Lautsprecher"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Kabelgebundene Kopfhörer"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Der Klang von kompatiblen Medien wird noch voller"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Aus"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"An / <xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"An / <xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> und <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Du kannst Spatial Audio auch für Bluetooth-Geräte aktivieren."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Einstellungen für verbundene Geräte"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Keine}=1{1 Zeitplan festgelegt}other{# Zeitpläne festgelegt}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Bitte nicht stören"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Benachrichtigungen nur von wichtigen Personen und Apps"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Unterbrechungen einschränken"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"„Bitte nicht stören“ aktivieren"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Wecker und Medientöne können ihn unterbrechen"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Zeitpläne"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Zeitpläne löschen"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Löschen"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Bearbeiten"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Zeitpläne"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Zeitplan"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Zeitplan"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Smartphone zu bestimmten Zeiten stummschalten"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"„Bitte nicht stören“-Regeln einrichten"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Zeitplan"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Zeitplan verwenden"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Unterbrechungen mit Tönen zulassen"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Visuelle Störungen blockieren"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Visuelle Signale zulassen"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Anzeigeoptionen für ausgeblendete Benachrichtigungen"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Wenn „Bitte nicht stören“ aktiviert ist"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Kein akustisches Signal bei Benachrichtigungen"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Benachrichtigungen werden angezeigt"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Wenn auf deinem Smartphone neue Benachrichtigungen eingehen, ist weder ein akustisches Signal zu hören noch eine Vibration zu spüren."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Kein optisches oder akustisches Signal bei Benachrichtigungen"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Du siehst und hörst keine Benachrichtigungen"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Du siehst auf deinem Smartphone keine neuen oder vorhandenen Benachrichtigungen. Außerdem vibriert es nicht und gibt keine akustischen Signale von sich. Beachte, dass wichtige Benachrichtigungen zu den Geräteaktivitäten und zum Gerätestatus weiterhin eingeblendet werden.\n\nNachdem du „Bitte nicht stören“ deaktiviert hast, kannst du vom oberen Bildschirmrand nach unten wischen, um die verpassten Benachrichtigungen zu sehen."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Benutzerdefiniert"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Benutzerdefinierte Einstellung aktivieren"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Benutzerdefinierte Einstellung entfernen"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Kein akustisches Signal bei Benachrichtigungen"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Teilweise ausgeblendet"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Kein optisches oder akustisches Signal bei Benachrichtigungen"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Benutzerdefinierte Einschränkungen"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Bei aktiviertem Display"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Bei deaktiviertem Display"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Töne und Vibration ausschalten"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Display nicht einschalten"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Benachrichtigungslicht blinkt nicht"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Keine Pop-up-Benachrichtigungen"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Symbole in der Statusleiste oben auf dem Bildschirm ausblenden"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"App-Benachrichtigungspunkte auf App-Symbolen ausblenden"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Ruhemodus nicht beenden"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Aus Benachrichtigungsleiste ausblenden"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nie"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Bei deaktiviertem Display"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Bei aktiviertem Display"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Töne und Vibration"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Töne, Vibration und einige visuelle Elemente von Benachrichtigungen"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Töne, Vibration und visuelle Elemente von Benachrichtigungen"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Benachrichtigungen für grundlegende Geräteaktivitäten und den Gerätestatus werden nie ausgeblendet."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Keine"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"sonstige Optionen"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Hinzufügen"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Aktivieren"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Jetzt aktivieren"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Jetzt deaktivieren"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"„Bitte nicht stören“ ist aktiviert bis <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Die Funktion „Bitte nicht stören“ bleibt aktiviert, bis du sie deaktivierst."</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"„Bitte nicht stören“ wurde automatisch durch einen Zeitplan (<xliff:g id="RULE_NAME">%s</xliff:g>) aktiviert"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"„Bitte nicht stören“ wurde automatisch durch eine App (<xliff:g id="APP_NAME">%s</xliff:g>) aktiviert"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"„Bitte nicht stören“ ist mit benutzerdefinierten Einstellungen für „<xliff:g id="RULE_NAMES">%s</xliff:g>“ aktiviert."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Benutzerdefinierte Einstellungen ansehen"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Nur wichtige Unterbrechungen"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>."</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="4803606180235742003">"An / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"An"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Jedes Mal fragen"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Bis zur Deaktivierung"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 Stunde}other{# Stunden}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 Minute}other{# Minuten}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Aus}=1{Aus / 1 Zeitplan kann automatisch aktiviert werden}other{Aus / # Zeitpläne können automatisch aktiviert werden}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Was den „Bitte nicht stören“-Modus unterbrechen kann"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Personen"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Apps"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Wecker &amp; sonstige Unterbrechungen"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Zeitpläne"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Gültigkeit der Schnelleinstellungen"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Allgemein"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Wenn „Bitte nicht stören“ aktiviert ist, ist weder ein akustisches Signal zu hören noch eine Vibration zu spüren. Mit den Einstellungen oben kannst du festlegen, welche Ausnahmen gelten sollten."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Benutzerdefinierte Einstellungen"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Zeitplan überprüfen"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Ok"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Benachrichtigungen"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Dauer"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Nachrichten, Termine &amp; Erinnerungen"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Wenn „Bitte nicht stören“ aktiviert ist, werden alle Nachrichten, Erinnerungen und Termine stummgeschaltet. Mit den Einstellungen oben kannst du festlegen, welche Ausnahmen gelten sollen. Die Nachrichteneinstellungen lassen sich anpassen, damit dich Freunde, Familie oder andere Kontakte erreichen können."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Fertig"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Einstellungen"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Kein optisches oder akustisches Signal bei Benachrichtigungen"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Kein Ton bei Benachrichtigungen"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Du siehst oder hörst keine Benachrichtigungen. Anrufe von markierten Kontakten und wiederholten Anrufern sind erlaubt."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Aktuelle Einstellung)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Einstellungen für „Bitte nicht stören“ ändern?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Töne für Arbeitsprofil"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Töne des privaten Profils verwenden"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Dieselben Töne verwenden wie beim privaten Profil"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Klingelton für Arbeitsprofil"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Standard-Benachrichtigungston für Arbeitsprofil"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Standard-Weckton für Arbeitsprofil"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Dieselben wie beim persönlichen Profil"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Töne des privaten Profils verwenden?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Bestätigen"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Für dein Arbeitsprofil werden dieselben Töne verwendet wie bei deinem privaten Profil."</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Benachrichtigungen"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Benachrichtigungsverlauf, Unterhaltungen"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Unterhaltung"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Verwalten"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"App-Benachrichtigungen"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Benachrichtigungen von einzelnen Apps verwalten"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Allgemein"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Geschäftliche Benachrichtigungen"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Arbeitsprofil"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Adaptive Priorität der Benachrichtigungen"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Benachrichtigungen mit niedriger Priorität automatisch auf \"Stumm\" schalten"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Adaptive Sortierung der Benachrichtigungen"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Benachrichtigungen automatisch nach Relevanz sortieren"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Feedback zu adaptiven Benachrichtigungen"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Änderungen an Benachrichtigungen und die Option für Systemfeedback anzeigen"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Wichtigkeit von Benachrichtigungen zurücksetzen"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Vom Nutzer geänderte Wichtigkeitseinstellungen zurücksetzen und dem Benachrichtigungsassistenten eine Priorisierung erlauben"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Aktions- und Antwortvorschläge"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Es werden automatisch Vorschläge für Aktionen und Antworten angezeigt"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Neue und zurückgestellte Benachrichtigungen anzeigen"</string>
    <string name="notification_history" msgid="8663811361243456201">"Benachrichtigungs­verlauf"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Benachrichtigungsverlauf verwenden"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Benachrichtigungsverlauf ist deaktiviert"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Benachrichtigungsverlauf aktivieren, um neue und zurückgestellte Benachrichtigungen zu sehen"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Keine aktuellen Benachrichtigungen"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Hier findest du aktuelle und zurückgestellte Benachrichtigungen"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"Benachrichtigungseinstellungen anzeigen"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"Benachrichtigung öffnen"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Schlummerfunktion für Benachrichtigungen zulassen"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Benachrich­ti­gungs­punkt auf App-Symbol"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Bubbles"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Bubbles"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Diese Unterhaltung als Bubble anzeigen"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Verschiebbares Symbol über anderen Apps anzeigen"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Bubbles für das Gerät aktivieren?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Wenn du die Bubbles für diese App aktivierst, wird die Funktion auch auf deinem Gerät aktiviert.\n\nDies wirkt sich auch auf andere Apps oder Unterhaltungen aus, die als Bubble erscheinen können."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Aktivieren"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Abbrechen"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"An / Unterhaltungen können als unverankerte Symbole angezeigt werden"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Zulassen, dass Apps Bubbles anzeigen"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Einige Unterhaltungen erscheinen als unverankerte Symbole über anderen Apps"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Alle Unterhaltungen können als Bubble erscheinen"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Ausgewählte Unter­hal­tun­gen können als Bubble erscheinen"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Unterhaltungen können nicht als Bubble erscheinen"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Unterhaltungen"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Alle Unterhaltungen können als Bubble erscheinen, außer"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Bubbles für diese Unterhaltung deaktivieren"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Bubbles für diese Unterhaltung aktivieren"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Nach rechts: schließen, nach links: Menü anzeigen"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Nach links: schließen, nach rechts: Menü anzeigen"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Lautlose Benachrichtigungen in der Statusleiste ausblenden"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Benachrichtigungslicht blinkt"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Datenschutz"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Sperrbildschirm überspringen"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Nach Entsperrung wird direkt der letzte Bildschirm angezeigt. Sperrbildschirm zeigt keine Benachrichtigungen. Um diese zu sehen, von oben wischen."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Sperrbildschirm, überspringen, umgehen"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Wenn das Arbeitsprofil gesperrt ist"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Nur neue Benachrichtigungen auf dem Sperrbildschirm anzeigen"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Zuvor angesehene Benachrichtigungen werden automatisch vom Sperrbildschirm entfernt"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Benachrichtigungen auf Sperrbildschirm"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Lautlose und Standardunterhaltungen anzeigen"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Alle Benachrichtigungen anzeigen"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Lautlose Unterhaltungen und Benachrichtigungen verbergen"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Keine Benachrichtigungen anzeigen"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Vertrauliche Benachrichtigungen"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Vertrauliche Inhalte auf dem Sperrbildschirm anzeigen"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Vertrauliche Benachrichtigungen aus Arbeitsprofilen"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Auf dem Sperrbildschirm werden vertrauliche Inhalte aus Arbeitsprofilen angezeigt"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Gesamten Benachrichtigungs­inhalt anzeigen"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Sensible Inhalte nur im entsperrten Zustand anzeigen"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Keine Benachrichtigungen anzeigen"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Wie sollen Benachrichtigungen auf dem Sperrbildschirm angezeigt werden?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Sperrbildschirm"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Alle geschäftlichen Benachrichtigungen anzeigen"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Vertrauliche geschäftliche Inhalte ausblenden"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Wie sollen Profilbenachrichtigungen angezeigt werden, wenn dein Gerät gesperrt ist?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Profilbenachrichtigungen"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Benachrichtigungen"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"App-Benachrichtigungen"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Benachrichtigungs­kategorie"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Verhalten"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Unterhaltungen"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Bereich „Unterhaltungen“"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"App darf den Bereich „Unterhaltungen“ nutzen"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Keine Unterhaltung"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Aus dem Bereich „Unterhaltungen“ entfernen"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Dies ist eine Unterhaltung"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Dem Bereich „Unterhaltungen“ hinzufügen"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Keine vorrangigen Unterhaltungen"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# priorisierte Unterhaltung}other{# priorisierte Unterhaltungen}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Vorrangige Unterhaltungen"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Oben im Bereich „Unterhaltungen“ und als unverankerte Bubbles anzeigen"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Oben im Bereich „Unterhaltungen“ anzeigen"</string>
    <string name="other_conversations" msgid="551178916855139870">"Unterhaltungen ohne Priorität"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Unterhaltungen, an denen Änderungen vorgenommen wurden"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Neueste Unterhaltungen"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Neueste Unterhaltungen löschen"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Neueste Unterhaltungen wurden entfernt"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Unterhaltung wurde entfernt"</string>
    <string name="clear" msgid="5092178335409471100">"Löschen"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Hier werden vorrangige und geänderte Unterhaltungen angezeigt"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Wenn du einer Unterhaltung Priorität gibst oder andere Änderungen daran vornimmst, wird sie hier angezeigt. \n\nSo änderst du die Einstellungen für eine Unterhaltung:\nWische vom oberen Displayrand nach unten, um die Benachrichtigungsleiste zu öffnen, und halte die entsprechende Unterhaltung gedrückt."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimieren"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Popup auf dem Bildschirm"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Lautlos"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Standard"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Unterbrechungen zulassen"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Die App darf Töne sowie Vibrationen erzeugen und/oder Pop-up-Benachrichtigungen auf dem Bildschirm einblenden"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Priorität"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Wird oben im Bereich „Unterhaltungen“ sowie als unverankerte Bubble angezeigt und erscheint mit einem Profilbild auf dem Sperrbildschirm"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> unterstützt die meisten Funktionen für Unterhaltungen nicht. Du kannst keine Unterhaltung als Priorität festlegen und Unterhaltungen erscheinen nicht als unverankerte Bubbles."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Benachrichtigungen in der Benachrichtigungsleiste werden auf eine Zeile minimiert"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Kein Ton und keine Vibration"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Kein Ton und keine Vibration, erscheint weiter unten im Bereich „Unterhaltungen“"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Kann je nach Geräteeinstellungen klingeln oder vibrieren"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Bei entsperrtem Gerät Benachrichtigungen als Banner oben auf dem Bildschirm anzeigen"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Alle Benachrichtigungen von „<xliff:g id="APP_NAME">%1$s</xliff:g>“"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Alle Benachrichtigungen von <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Etwa # Benachrichtigung pro Tag}other{Etwa # Benachrichtigungen pro Tag}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Etwa # Benachrichtigung pro Woche}other{Etwa # Benachrichtigungen pro Woche}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nie"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Geräte- und App-​Benachrichtigungen"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Festlegen, welche Apps und Geräte Benachrichtigungen lesen dürfen"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Zugriff auf Arbeitsprofil-Benachrichtigungen ist blockiert"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Erweiterte Benachrichtigungen"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Vorgeschlagene Aktionen, Antworten und mehr erhalten"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Kein Dienst"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Keine installierte App hat Benachrichtigungszugriff angefordert."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Benachrichtigungszugriff erlauben"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Die adaptiven Benachrichtigungen wurden in Android 12 durch die Funktion „Erweiterte Benachrichtigungen“ ersetzt. Diese Funktion zeigt Vorschläge für Aktionen und Antworten an und sortiert Benachrichtigungen. \n\nDie Funktion hat Zugriff auf alle Benachrichtigungen, darunter auch personenbezogene Daten wie Kontaktnamen und Nachrichten. Außerdem kann sie auf Benachrichtigungen antworten oder diese schließen und so beispielsweise Anrufe entgegennehmen oder „Bitte nicht stören“ steuern."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Benachrichtigungszugriff für <xliff:g id="SERVICE">%1$s</xliff:g> zulassen?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"Die App „<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>“ kann alle Benachrichtigungen lesen, darunter auch personenbezogene Daten wie Kontaktnamen, Fotos und eingehende Nachrichten. Außerdem kann die App Benachrichtigungen zurückstellen oder schließen sowie Schaltflächen in Benachrichtigungen auslösen und so beispielsweise Anrufe entgegennehmen. \n\nZusätzlich wird sie in die Lage versetzt, die „Bitte nicht stören“-Funktion zu aktivieren oder zu deaktivieren und zugehörige Einstellungen zu ändern."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Die App „<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>“ kann Folgendes:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Benachrichtigungen abrufen"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Sie kann deine Benachrichtigungen abrufen, darunter auch personenbezogene Daten wie Kontakte, Nachrichten und Fotos."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Nachrichten beantworten"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Sie kann auf Nachrichten antworten und Schaltflächen in Benachrichtigungen auslösen, beispielsweise Benachrichtigungen zurückstellen oder schließen und Anrufe entgegennehmen."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Einstellungen ändern"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Sie kann die „Bitte nicht stören“-Funktion aktivieren oder deaktivieren und zugehörige Einstellungen ändern."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Wenn du den Benachrichtigungszugriff für <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> deaktivierst, wird möglicherweise auch der „Bitte nicht stören“-Zugriff deaktiviert."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Deaktivieren"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Abbrechen"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Echtzeit"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Aktuelle Mitteilungen von Apps, die in Verwendung sind, Navigation, Telefonanrufe und mehr"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Unterhaltungen"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS und andere Nachrichten"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Benachrichtigungen"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Kann klingeln oder vibrieren, abhängig von den Einstellungen"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Lautlos"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Benachrichtigungen, die nie Töne oder Vibrationen auslösen"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Zugelassen"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Nicht zugelassen"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Alle Apps anzeigen"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Einstellungen für jede App ändern, die Benachrichtigungen senden kann"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Auf Gerät angezeigte Apps"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Diese App unterstützt erweiterte Einstellungen nicht"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Weitere Einstellungen"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Weitere Einstellungen sind in dieser App verfügbar"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"VR-Hilfsdienste"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Keine installierte App hat die Ausführung als VR-Hilfedienst angefordert."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"VR-Dienstzugriff für <xliff:g id="SERVICE">%1$s</xliff:g> erlauben?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> kann ausgeführt werden, wenn der Modus für virtuelle Realität für Apps aktiviert wird."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Wenn das Gerät im VR-Modus ist"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Unschärfe reduzieren (empfohlen)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Flimmern reduzieren"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Bild im Bild"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Keine der installierten Apps unterstützt den Bild-im-Bild-Modus"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"bib, bild in bild, bild, in"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Bild im Bild"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Bild im Bild zulassen"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Während die App geöffnet ist oder nachdem du sie verlässt (z. B. um ein Video weiter anzusehen), öffnet die App ein Bild-im-Bild-Fenster. Das Fenster wird über anderen Apps eingeblendet, die du gerade verwendest."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Verknüpfte private &amp; geschäftliche Apps"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Verknüpft"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Nicht verknüpft"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Keine verknüpften Apps"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"profilübergreifend verknüpfte App geschäftliche und private Apps"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Verknüpft"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Diese Apps verknüpfen"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Für miteinander verknüpfte Apps gelten dieselben Berechtigungen und jede App kann auf die Daten der anderen App zugreifen."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Verknüpfe nur Apps, bei denen du sicher bist, dass sie deinem IT-Administrator keinen Zugriff auf deine personenbezogenen Daten gewähren."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Du kannst die Verknüpfung der Apps jederzeit in den Datenschutzeinstellungen deines Geräts aufheben."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Darf die geschäftliche App „<xliff:g id="NAME">%1$s</xliff:g>“ auf deine personenbezogenen Daten zugreifen?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Verknüpfe nur Apps, bei denen du sicher bist, dass sie deinem IT-Administrator keinen Zugriff auf deine personenbezogenen Daten gewähren."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"App-Daten"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Diese App kann auf Daten in deiner privaten App „<xliff:g id="NAME">%1$s</xliff:g>“ zugreifen."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Berechtigungen"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Diese App kann die Berechtigungen deiner privaten App „<xliff:g id="NAME">%1$s</xliff:g>“ nutzen, wie etwa den Zugriff auf Standort, Speicher oder Kontakte."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Keine Apps verknüpft"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# App verbunden}other{# Apps verbunden}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Wenn du diese Apps verknüpfen möchtest, installiere die App „<xliff:g id="NAME">%1$s</xliff:g>“ in deinem Arbeitsprofil"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Wenn du diese Apps verknüpfen möchtest, installiere die App „<xliff:g id="NAME">%1$s</xliff:g>“ in deinem privaten Profil"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Zum Herunterladen der App tippen"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Zugriff während „Bitte nicht stören“"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"„Bitte nicht stören“ zulassen"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Keine installierte App hat während „Bitte nicht stören“ Zugriff angefordert."</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Von dieser App sind keine Benachrichtigungen zugelassen"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Gemäß deinen Einstellungen unterbindet Android die Anzeige von Benachrichtigungen dieser Kategorie auf diesem Gerät."</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Gemäß deinen Einstellungen unterbindet Android die Anzeige von Benachrichtigungen dieser Gruppe auf diesem Gerät."</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Diese App sendet keine Benachrichtigungen"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategorien"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Andere"</string>
    <string name="no_channels" msgid="4716199078612071915">"Für diese App gibt es keine Benachrichtigungen"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Zusätzliche Einstellungen in der App"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# Kategorie gelöscht}other{# Kategorien gelöscht}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Alle blockieren"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Diese Benachrichtigungen nie anzeigen"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Benachrichtigungen anzeigen"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Benachrichtigungen nie in der Leiste oder auf Peripheriegeräten anzeigen"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Vollbildbenachrichtigungen erlauben"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Die App darf Benachrichtigungen anzeigen, die das gesamte Display ausfüllen, wenn das Gerät gesperrt ist"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"App-Benach­rich­ti­gungs­punkt erlauben"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"App-Benach­richtigungs­punkt anzeigen"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"„Bitte nicht stören“ ignorieren"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Diese Benachrichtigungen dürfen auch dann gemeldet werden, wenn „Bitte nicht stören“ aktiviert ist"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Sperrbildschirm"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Fertig"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Benachrichtigungslicht blinkt"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibration"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Ton"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Priorität"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Name des Zeitplans"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Name für Zeitplan eingeben"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Name für Zeitplan bereits verwendet"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Weitere hinzufügen"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Terminbasierten Zeitplan hinzufügen"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Uhrzeitbasierten Zeitplan hinzufügen"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Zeitplantyp auswählen"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Regel „<xliff:g id="RULE">%1$s</xliff:g>“ löschen?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Löschen"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Diese Einstellungen können derzeit nicht geändert werden. Durch eine App (<xliff:g id="APP_NAME">%1$s</xliff:g>) wurde „Bitte nicht stören“ automatisch mit benutzerdefiniertem Verhalten aktiviert."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Diese Einstellungen können derzeit nicht geändert werden. Durch eine App wurde „Bitte nicht stören“ automatisch mit benutzerdefiniertem Verhalten aktiviert."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Diese Einstellungen können derzeit nicht geändert werden. „Bitte nicht stören“ wurde mit benutzerdefiniertem Verhalten manuell aktiviert."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Uhrzeit"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Termin"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Bei Terminen aus diesem Kalender:"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Alle Kalender"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Bei folgenden Antworten:"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"„Ja“, „Vielleicht“ oder „Keine Antwort“"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"„Ja“ oder „Vielleicht“"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Ja"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Regel nicht gefunden"</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"An / <xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n: <xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="8633770815307716351">"Tage"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Keine"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Wecker kann Schlusszeit außer Kraft setzen"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Zeitplan wird deaktiviert, wenn ein Wecker klingelt"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"„Bitte nicht stören“-Verhalten"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Standardeinstellungen verwenden"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Benutzerdefinierte Einstellungen festlegen"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Für „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>“"</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g>–<xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Unterhaltungen"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Alle Unterhaltungen"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Vorrangige Unterhaltungen"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"Priorisierte Unterhaltungen"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Keine"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Keine}=1{1 Unterhaltung}other{# Unterhaltungen}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Wer unterbrechen darf"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Nachrichten- oder Anruf-Apps können dich zwar nicht benachrichtigen, aber die von dir hier ausgewählten Nutzer können dich trotzdem über diese Apps erreichen"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Anrufe"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Anrufe"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"Anrufe"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Anrufe, die unterbrechen dürfen"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Damit bei zugelassenen Anrufen auch wirklich ein akustisches Signal ertönt, muss der Klingeltonmodus aktiviert sein"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Im Modus „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>“ werden eingehende Anrufe blockiert. Du kannst die Einstellungen anpassen, sodass dich Freunde, Familienmitglieder oder andere Kontakte erreichen können."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Markierte Kontakte"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Keiner}=1{{contact_1}}=2{{contact_1} und {contact_2}}=3{{contact_1}, {contact_2} und {contact_3}}other{{contact_1}, {contact_2} und # weitere Kontakte}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Kein Name)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Nachrichten"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"Nachrichten"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Nachrichten"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Nachrichten, die unterbrechen dürfen"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Damit bei zugelassenen Nachrichten auch wirklich ein akustisches Signal ertönt, muss der Klingeltonmodus aktiviert sein"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Im Modus „<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>“ werden eingehende Nachrichten blockiert. Du kannst die Einstellungen anpassen, sodass dich Freunde, Familienmitglieder oder andere Kontakte erreichen können."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Alle Nachrichten können dich erreichen"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Alle Anrufe können dich erreichen"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Keiner}=1{1 Kontakt}other{# Kontakte}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Alle"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontakte"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Markierte Kontakte"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Keine"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Keine"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Wecker"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Von Timern, Weckern, Sicherheitssystemen und sonstigen Apps"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"Wecker"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Wecker"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Medientöne"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Ton von Videos, Spielen und sonstigen Medien"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"Medien"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Medien"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Töne bei Berührung"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Töne von der Tastatur und sonstigen Schaltflächen"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"Töne bei Berührung"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Töne bei Berührung"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Erinnerungen"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Von Aufgaben und Erinnerungen"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"Erinnerungen"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Erinnerungen"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Kalendertermine"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Von anstehenden Terminen"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"Termine"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Termine"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Überschreiben durch Apps zulassen"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Apps, die unterbrechen dürfen"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Weitere Apps auswählen"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Keine Apps ausgewählt"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Keine Apps können ihn unterbrechen"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Apps hinzufügen"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Alle Benachrichtigungen"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Einige Benachrichtigungen"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Ausgewählte Personen können dich weiterhin erreichen, auch wenn du nicht zulässt, dass Apps dich unterbrechen."</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Keine Apps können ihn unterbrechen}=1{Die App „{app_1}“ kann ihn unterbrechen}=2{Die Apps „{app_1}“ und „{app_2}“ können ihn unterbrechen}=3{Die Apps „{app_1}“, „{app_2}“ und „{app_3}“ können ihn unterbrechen}other{Die App „{app_1}“, „{app_2}“ und # weitere können ihn unterbrechen}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Apps"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Benachrichtigungen, die unterbrechen dürfen"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Alle Benachrichtigungen zulassen"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Nichts kann ihn unterbrechen}=1{Geräusche der Kategorie „{sound_category_1}“ können ihn unterbrechen}=2{Geräusche der Kategorie „{sound_category_1}“ und „{sound_category_2}“ können ihn unterbrechen}=3{Geräusche der Kategorie „{sound_category_1}“, „{sound_category_2}“ und „{sound_category_3}“ können ihn unterbrechen}other{Geräusche der Kategorie „{sound_category_1}“, „{sound_category_2}“ und # weiteren können ihn unterbrechen}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Nichts kann ihn unterbrechen"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Niemand kann ihn unterbrechen"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Einige Personen können ihn unterbrechen"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Alle Personen können ihn unterbrechen"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Wiederholte Anrufer"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Wiederholte Anrufer zulassen"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"Alle"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"Kontakten"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"markierten Kontakten"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"wiederholte Anrufer"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> und <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Wenn dieselbe Person innerhalb von <xliff:g id="MINUTES">%d</xliff:g> Minuten noch einmal anruft"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Startzeit"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Schlusszeit"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"Am nächsten Tag um <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Für unbegrenzte Zeit zur Option \"Nur Weckrufe\" wechseln"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Eine Minute lang bis {time} zur Option „nur Weckrufe“ wechseln}other{# Minuten lang bis {time} zur Option „nur Weckrufe“ wechseln}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Eine Stunde lang bis {time} zur Option „nur Weckrufe“ wechseln}other{# Stunden lang bis {time} zur Option „nur Weckrufe“ wechseln}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Bis <xliff:g id="FORMATTEDTIME">%1$s</xliff:g> zur Option \"Nur Weckrufe\" wechseln"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Zur Option \"Immer unterbrechen\" wechseln"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Warnung"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Schließen"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Feedback zu diesem Gerät senden"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Administrator-PIN eingeben"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"An"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Aus"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"An"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Aus"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"An"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Aus"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Bildschirmfixierung"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Mit der Option „Bildschirmfixierung“ kannst du festlegen, dass auf deinem Gerät vorübergehend nur eine App ausgeführt und angezeigt wird. Auf diese Weise kannst du z. B. jemanden ein bestimmtes Spiel auf deinem Gerät spielen lassen."</string>
    <string name="screen_pinning_description" msgid="4305370471370474846">"Die App, die während der Bildschirmfixierung angezeigt wird, kann unter Umständen andere Apps öffnen, wodurch private Daten zugänglich gemacht werden können. \n\nSo verwendest du die Funktion „Bildschirmfixierung“: 	\n1. Aktiviere „Bildschirmfixierung“ 	\n2. Tippe auf „Übersicht“ 	\n3. Tippe auf das App-Symbol oben auf dem Bildschirm und dann auf „Fixieren“"</string>
    <string name="screen_pinning_guest_user_description" msgid="2465729370037556955">"Die App, die während der Bildschirmfixierung angezeigt wird, kann unter Umständen andere Apps öffnen, wodurch private Daten zugänglich gemacht werden können. \n\nWenn du dein Gerät sicher mit jemandem teilen möchtest, kannst du stattdessen ein Gastprofil verwenden. \n\nSo verwendest du die Funktion „Bildschirmfixierung“: 	\n1. Aktiviere „Bildschirmfixierung“ 	\n2. Tippe auf „Übersicht“ 	\n3. Tippe auf das App-Symbol oben auf dem Bildschirm und dann auf „Fixieren“"</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Wenn eine App auf dem Bildschirm fixiert ist, gilt Folgendes: \n\n•	 Personenbezogene Daten könnten dennoch\nzugänglich sein (z. B. Kontakte oder E-Mails) \n• Eine fixierte App kann andere Apps öffnen \n\nVerwende die Funktion „Bildschirmfixierung“ nur dann, wenn du deinem Gegenüber vertraust."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Zum Loslösen nach Entsperrungsmuster fragen"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Vor Beenden nach PIN fragen"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Vor dem Beenden nach Passwort fragen"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Gerät beim Loslösen der App sperren"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Löschen der SIM bestätigen"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Bestätige deine Identität, um eine eSIM zu löschen"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Erweiterter-Speicherschutz-Beta"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Erweiterter Speicherschutz"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Diese Betafunktion trägt zum Schutz deines Geräts vor Fehlern bei, die ein Sicherheitsrisiko für dich darstellen können."</string>
    <string name="memtag_on" msgid="824938319141503923">"An"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Aus"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"An nach Neustart"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Aus nach Neustart"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Derzeit nicht für das Gerät verfügbar"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Für dein Gerät immer aktiviert"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Du musst dein Gerät neu starten, um den erweiterten Speicherschutz zu aktivieren oder zu deaktivieren. Wenn der Schutz aktiviert ist, kann das die Geräteleistung beeinträchtigen."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Gerät neu starten?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Du musst dein Gerät neu starten, um den erweiterten Speicherschutz zu aktivieren."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Du musst dein Gerät neu starten, um den erweiterten Speicherschutz zu deaktivieren."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Neu starten"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Nicht jetzt"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Weitere Informationen zum erweiterten Speicherschutz."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Dieses Arbeitsprofil wird verwaltet von:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Verwaltet von <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Standardmäßig öffnen"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Unterstützte Links öffnen"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Zulassen, dass Links in dieser App geöffnet werden"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Links, die in dieser App geöffnet werden sollen"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Unterstützte Links"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Andere Standardeinstellungen"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Link hinzufügen"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Eine App kann Links überprüfen, um sie automatisch zu öffnen."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# bestätigter Link}other{# bestätigte Links}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Dieser Link ist bestätigt und wird automatisch in dieser App geöffnet.}other{Diese Links sind bestätigt und werden automatisch in dieser App geöffnet.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"OK"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Liste der Bestätigungslinks anzeigen"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Andere unterstützte Links werden gesucht…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Abbrechen"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# unterstützter Link}other{# unterstützte Links}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Hinzufügen"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Wird in <xliff:g id="APP_LABEL">%s</xliff:g> geöffnet"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> <xliff:g id="STORAGE_TYPE">%2$s</xliff:g> belegt"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"interner Speicher"</string>
    <string name="storage_type_external" msgid="125078274000280821">"externer Speicher"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> seit <xliff:g id="DATE">%2$s</xliff:g> genutzt"</string>
    <string name="storage_used" msgid="2591194906751432725">"Genutzter Speicher"</string>
    <string name="change" msgid="273206077375322595">"Ändern"</string>
    <string name="change_storage" msgid="8773820275624113401">"Speicher ändern"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Benachrichtigungen"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"An"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g>/<xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="5603160425378437143">"Aus"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# Kategorie deaktiviert}other{# Kategorien deaktiviert}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# zusätzliche Berechtigung}other{# zusätzliche Berechtigungen}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Keine Berechtigungen gewährt"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Keine Berechtigungen angefordert"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"App-Zugriff auf Daten festlegen"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Privatsphäre­dashboard"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Anzeigen, welche Apps zuletzt Berechtigungen genutzt haben"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Nicht verwendete Apps"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# nicht verwendete App}other{# nicht verwendete Apps}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Einstellungen für App bei Nichtnutzung"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"App-Aktivität bei Nichtnutzung stoppen"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Berechtigungen entfernen, temporäre Dateien löschen und Benachrichtigungen stoppen"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Alle Apps"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Installierte Apps"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Instant Apps"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Deaktiviert"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Erweitert"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Berechtigungs­manager"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Änderungen bei der Weitergabe von Standortdaten"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Apps ansehen, bei denen sich die Art der Weitergabe deiner Standortdaten geändert hat"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Zum Aktivieren tippen"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Tippe doppelt auf den Bildschirm, um das Gerät zu aktivieren."</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Links öffnen"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Unterstützte Links nicht öffnen"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"<xliff:g id="DOMAIN">%s</xliff:g> öffnen"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"<xliff:g id="DOMAIN">%s</xliff:g> und andere URLs öffnen"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"App darf unterstützte Links öffnen"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Jedes Mal fragen"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"App darf keine Links öffnen"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{App gibt an, # Link zu verarbeiten}other{App gibt an, # Links zu verarbeiten}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"App gibt an, die folgenden Links zu verarbeiten:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Assistent &amp; Spracheingabe"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"App für digitalen Assistenten"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Standard-App digit. Assistent"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Zustimmen"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Browser-App"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Telefonie-App"</string>
    <string name="system_app" msgid="1863291702508355041">"(System)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Speicher für Apps"</string>
    <string name="usage_access" msgid="5487993885373893282">"Zugriff auf Nutzungsdaten"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Zugriff auf Nutzungsdaten gewähren"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Bildschirmzeit"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Der Zugriff auf die Nutzungsdaten ermöglicht es einer App, verschiedene Informationen zu erfassen – welche anderen Apps du wie oft verwendest, welchen Mobilfunkanbieter du nutzt, welche Spracheinstellungen du festgelegt hast usw."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Arbeitsspeicher"</string>
    <string name="always_running" msgid="9012705720688200252">"Immer ausgeführt (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Gelegentlich ausgeführt (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Kaum ausgeführt (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g>/<xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Akkuoptimierung"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Nicht optimiert"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Nicht optimiert"</string>
    <string name="high_power_off" msgid="317000444619279018">"Akkunutzung optimieren"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Akkuoptimierung nicht verfügbar"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Soll die App immer im Hintergrund ausgeführt werden?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Wenn du erlaubst, dass <xliff:g id="APP_NAME">%1$s</xliff:g> dauerhaft im Hintergrund ausgeführt wird, kann dies die Akkulaufzeit verringern. \n\nDu kannst das später unter „Einstellungen“ &gt; „Apps“ ändern."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> Verbrauch seit dem letzten kompletten Aufladen"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> Nutzung in den letzten 24 Stunden"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Kein Verbrauch seit dem letzten kompletten Aufladen"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Fehlerbericht teilen?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Dein IT-Administrator hat einen Fehlerbericht zur Fehlerbehebung für dieses Gerät angefordert. Apps und Daten werden unter Umständen geteilt."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Dein IT-Administrator hat einen Fehlerbericht zur Fehlerbehebung für dieses Gerät angefordert. Apps und Daten werden unter Umständen geteilt und dein Gerät wird möglicherweise vorübergehend langsamer."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Dieser Fehlerbericht wird mit deinem IT-Administrator geteilt. Bei Bedarf kannst du ihn um weitere Informationen bitten."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Teilen"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Ablehnen"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Keine Datenübertragung"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Verbundenes Gerät aufladen"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Dateiübertragung"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Webcam"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Videos zu AVC konvertieren"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Die Videos sind mit einer größeren Zahl von Mediaplayern kompatibel, es kann jedoch zu Qualitätseinbußen kommen"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"USB-Tethering"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Verwendungszweck für USB-Verbindung"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Standard-USB-Konfiguration"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Wenn ein anderes Gerät verbunden und dein Smartphone entsperrt ist, werden diese Einstellungen angewendet. Stell nur Verbindungen zu vertrauenswürdigen Geräten her."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Optionen für Stromversorgung"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Optionen zur Dateiübertragung"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"USB-Einstellungen"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"Gerät, das die USB-Verbindung steuert"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Verbundenes Gerät"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Dieses Gerät"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Wird gewechselt…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Wechsel nicht möglich"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Dieses Gerät aufladen"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Verbundenes Gerät wird aufgeladen"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Dateiübertragung"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"USB-Tethering"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Webcam"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Dateiübertragung und Stromversorgung"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"USB-Tethering und Stromversorgung"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP und Stromversorgung"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI und Stromversorgung"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Webcam und Stromversorgung"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Hintergrundprüfung"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Auf Bildschirmtext zugreifen"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Der Assistent-App erlauben, den Bildschirminhalt als Text zu verwenden"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Screenshot verwenden"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Der Assistent-App den Zugriff auf eine Aufnahme deines Bildschirms gestatten"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Bildschirm kurz aufleuchten lassen"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Bildschirmränder kurz aufleuchten lassen, wenn die Assistent-App auf Bildschirmtext oder Screenshot zugreift"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Assistent-Apps können dir bei bestimmten Dingen helfen. Dazu greifen sie auf die Informationen zu, die aktuell auf deinem Bildschirm angezeigt werden. Damit sie dir eine umfassende Hilfe sind, unterstützen einige Apps sowohl Launcher- als auch Spracheingabedienste."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Durchschnittl. Speicherverbrauch"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maximaler Speicherverbrauch"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Speicherverbrauch"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"App-Nutzung"</string>
    <string name="memory_details" msgid="6133226869214421347">"Details"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"<xliff:g id="SIZE">%1$s</xliff:g> durchschnittlicher Speicherverbrauch in den letzten drei Stunden"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Kein Speicherverbrauch in den letzten drei Stunden"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Nach durchschnittlichem Verbrauch sortieren"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Nach maximalem Verbrauch sortieren"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Leistung"</string>
    <string name="total_memory" msgid="5244174393008910567">"Gesamtspeicherplatz"</string>
    <string name="average_used" msgid="690235917394070169">"Durchschnitt. verbraucht (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Frei"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Von Apps verbrauchter Speicher"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 App nutzte Arbeitsspeicher in den letzten {time}}other{# Apps nutzten Arbeitsspeicher in den letzten {time}}}"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Häufigkeit"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maximaler Verbrauch"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Keine Daten genutzt"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Zugriff auf „Bitte nicht stören“ für <xliff:g id="APP">%1$s</xliff:g> zulassen?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Die App kann „Bitte nicht stören“ aktivieren/deaktivieren und Änderungen an verwandten Einstellungen vornehmen."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Muss aktiviert bleiben, weil der Benachrichtigungszugriff aktiviert ist"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Zugriff auf „Bitte nicht stören“ für <xliff:g id="APP">%1$s</xliff:g> aufheben?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Alle von dieser App erstellten „Bitte nicht stören“-Regeln werden entfernt."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Nicht optimieren"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimieren"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Der Akku könnte hierdurch schneller leer sein, denn die App kann jetzt auch im Hintergrund Energie verbrauchen."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Zur Verlängerung der Akkulaufzeit empfohlen"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Keine App"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Das Deaktivieren des Zugriffs auf Nutzungsdaten für diese App hindert deinen Administrator nicht am Erfassen der Datennutzung für Apps in deinem Arbeitsprofil"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Über anderen Apps einblenden"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Über anderen Apps einblenden"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Einblendung über anderen Apps zulassen"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Erlaube, dass diese App über anderen Apps, die du gerade verwendest, eingeblendet wird. Diese App erkennt, wo du tippst oder welche Elemente auf dem Bildschirm du änderst."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Zugriff auf alle Dateien"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Zugriff zum Verwalten aller Dateien zulassen"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Du kannst dieser App erlauben, alle Dateien auf diesem Gerät und auf allen verbundenen Laufwerken zu lesen, zu ändern und zu löschen. Sie kann dann ohne deine explizite Zustimmung auf Dateien zugreifen."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Auf alle Dateien zugreifen"</string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Vollbildbenachrichtigungen"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Vollbildbenachrichtigungen von dieser App erlauben"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Diese App darf Benachrichtigungen anzeigen, die das gesamte Display ausfüllen, wenn das Gerät gesperrt ist. Apps können diese verwenden, um Wecker, eingehende Anrufe oder andere dringende Benachrichtigungen hervorzuheben."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Apps zur Medienverwaltung"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"App erlauben, Medien zu verwalten"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Wenn du es erlaubst, kann diese App Mediendateien ändern oder löschen, die mit anderen Apps erstellt wurden, ohne dich zu fragen. Die App muss berechtigt sein, auf Mediendateien zuzugreifen."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Medien, Datei, Verwaltung, Verwalter, verwalten, bearbeiten, Bearbeiter, App, Anwendung, Programm"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr virtuelle realität listener stereo hilfe dienst"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Über anderen Apps einblenden"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Apps mit Berechtigung"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Zugelassen"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Nicht zugelassen"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"apps installieren aus unbekannten quellen"</string>
    <string name="write_settings" msgid="6864794401614425894">"Systemeinstellungen ändern"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"systemeinstellungen schreiben ändern"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Installation anderer Apps erlaubt"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Kann Systemeinstellungen ändern"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Kann Systemeinstellungen ändern"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Systemeinstellungen ändern"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Änderung von Systemeinstellungen zulassen"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Diese Berechtigung ermöglicht einer App das Ändern von Systemeinstellungen."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Dieser Quelle vertrauen"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Zum Öffnen der Kamera zweimal drehen"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Kamera-App durch zweimaliges Drehen des Handgelenks öffnen"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Anzeigegröße"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Alles vergrößern oder verkleinern"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"kompaktheitsgrad, bildschirm zoom, display zoom, maßstab, skalierung, skalieren"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Vorschau"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Verkleinern"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Vergrößern"</string>
    <string name="disconnected" msgid="3469373726996129247">"Nicht verbunden"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Nicht verbunden"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> Apps installiert"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> belegt – <xliff:g id="FREE_SPACE">%2$s</xliff:g> frei"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Dunkles Design, Schriftgröße, Helligkeit"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Im Mittel werden <xliff:g id="USED_MEMORY">%1$s</xliff:g> von <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> genutzt"</string>
    <string name="users_summary" msgid="8473589474976307510">"Angemeldet als <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Aktualisiert auf Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Update verfügbar"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Durch Arbeitsrichtlinie blockiert"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Lautstärke nicht änderbar"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Starten von Anrufen nicht möglich"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Senden von SMS nicht möglich"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Verwenden der Kamera nicht möglich"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Erstellen von Screenshots nicht möglich"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"App kann nicht geöffnet werden"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Von deinem Kreditinstitut blockiert"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Elternerlaubnis erforderlich"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Gib das Smartphone einem Elternteil, um mit der Einrichtung zu beginnen"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Gib das Smartphone zum Ändern dieser Einstellung einem Elternteil."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Wenn du mehr wissen möchtest, wende dich an deinen IT-Administrator"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Weitere Details"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Dein Administrator kann die mit deinem Arbeitsprofil verbundenen Apps und Daten überwachen und verwalten, einschließlich der Einstellungen, Berechtigungen, Zugriffe auf Unternehmensinhalte, Netzwerkaktivitäten und Standortdaten des Geräts."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Dein Administrator kann die mit diesem Nutzer verbundenen Apps und Daten überwachen und verwalten, einschließlich der Einstellungen, Berechtigungen, Zugriffe auf Unternehmensinhalte, Netzwerkaktivitäten und Standortdaten des Geräts."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Dein Administrator kann die mit diesem Gerät verbundenen Apps und Daten überwachen und verwalten, einschließlich der Einstellungen, Berechtigungen, Zugriffe auf Unternehmensinhalte, Netzwerkaktivitäten und Standortdaten des Geräts."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Dein Geräteadministrator kann möglicherweise auf die Daten zugreifen, die mit diesem Gerät verknüpft sind, Apps verwalten und die Geräteeinstellungen ändern."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Deaktivieren"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Aktivieren"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Anzeigen"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Ausblenden"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Hotspot ist aktiv"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Flugmodus ist aktiviert"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Netzwerke nicht verfügbar"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"„Bitte nicht stören“ aktiviert"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Smartphone stummgeschaltet"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Mit Ausnahmen"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Energiesparmodus aktiviert"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funktionen eingeschränkt"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobile Daten sind deaktiviert"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet nur über WLAN verfügbar"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Datensparmodus"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funktionen eingeschränkt"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Arbeitsprofil deaktiviert"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Für Apps &amp; Benachrichtigungen"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Ton einschalten"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Klingelton stummgeschaltet"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Für Anrufe &amp; Benachrichtigungen"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Nur Vibration"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Für Anrufe &amp; Benachrichtigungen"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Zeitplan für Nachtlicht einrichten"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Jede Nacht automatisch Nachtlicht für Bildschirm einschalten"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Das Nachtlicht ist eingeschaltet"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Gelb gefärbter Bildschirm"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Graustufen"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Nur in Graustufen anzeigen"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Minimieren"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Kalte Farbtemperatur"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Kältere Displayfarben verwenden"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Deaktiviere den Bildschirm, um die neue Farbeinstellung zu übernehmen"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Kamera-Lasersensor"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automatische Systemupdates"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Updates ausführen, wenn das Gerät neu gestartet wird"</string>
    <string name="usage" msgid="287782903846013936">"Nutzung"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Mobile Datennutzung"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Datennutzung durch Apps"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"WLAN-Datennutzung"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Datennutzung ohne Mobilfunknetzdaten"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Ethernet-Datennutzung"</string>
    <string name="wifi" msgid="2932584495223243842">"WLAN"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> mobile Daten"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> WLAN-Datennutzung"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> Ethernet-Datennutzung"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Datenwarnung und -limit"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Nutzungszyklus mobile Daten"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Warnlimit für mobile Datennutzung: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Datenlimit: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Warnlimit für mobile Datennutzung: <xliff:g id="ID_1">^1</xliff:g>/Datenlimit: <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="operator_warning" msgid="5672761970087591211">"Dein Mobilfunkanbieter berechnet die Datennutzung eventuell anders als das Gerät"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Beinhaltet keine im Mobilfunknetz verbrauchten Daten"</string>
    <string name="data_used_template" msgid="8229342096562327646">"Verbrauchte Daten: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Datenwarnung festlegen"</string>
    <string name="data_warning" msgid="2925054658166062884">"Warnlimit für mobile Daten"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Die Berechnung, wann das Warnlimit für die Nutzung mobiler Daten und das Datenlimit erreicht sind, erfolgt durch das Gerät. Die Nutzungsangaben des Mobilfunkanbieters können abweichen."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Datenlimit festlegen"</string>
    <string name="data_limit" msgid="8731731657513652363">"Datenlimit"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"Datennutzung im Zeitraum <xliff:g id="ID_2">%2$s</xliff:g>: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Konfigurieren"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Weitere Apps, die ebenfalls Daten verbraucht haben"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 App darf trotz aktiviertem Datensparmodus uneingeschränkt Daten nutzen}other{# Apps dürfen trotz aktiviertem Datensparmodus uneingeschränkt Daten nutzen}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Primärdaten"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"WLAN-Daten"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"<xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> verbraucht"</string>
    <string name="data_overusage" msgid="3680477320458707259">"<xliff:g id="ID_1">^1</xliff:g> über dem Limit"</string>
    <string name="data_remaining" msgid="6316251496381922837">"<xliff:g id="ID_1">^1</xliff:g> verbleibend"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Grafik zeigt Datennutzung zwischen dem <xliff:g id="START_DATE">%1$s</xliff:g> und dem <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Keine Daten für diesen Zeitraum vorhanden"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{Noch # Tag}other{Noch # Tage}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Keine Zeit übrig"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Noch weniger als 1 Tag"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Vor <xliff:g id="ID_2">^2</xliff:g> von <xliff:g id="ID_1">^1</xliff:g> aktualisiert"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Vor <xliff:g id="ID_1">^2</xliff:g> aktualisiert"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Gerade von <xliff:g id="ID_1">^1</xliff:g> aktualisiert"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Gerade aktualisiert"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Tarif anzeigen"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Details ansehen"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Datensparmodus"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Uneingeschränkte Datennutzung"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Hintergrunddaten sind deaktiviert"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"An"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Aus"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Datensparmodus verwenden"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Uneingeschränkte Datennutzung"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Im Datensparmodus uneingeschränkte Datennutzung erlauben"</string>
    <string name="home_app" msgid="6056850504746902747">"Start-App"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Weiteren Fingerabdruck hinzufügen"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Mit einem anderen Finger entsperren"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"An"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Wird bei <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> aktiviert"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Aus"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Akkunutzung der App"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Akkunutzung für Apps festlegen"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Uneingeschränkt"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimiert"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Eingeschränkt"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Standardrechtschreibprüfung"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Rechtschreibprüfung wählen"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Rechtschreibprüfung verwenden"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Nicht ausgewählt"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"Paket"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"Taste"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"Gruppe"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(Zusammenfassung)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"Öffentliche Version"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"Wichtigkeit"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"Erklärung"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"Kann ein Logo anzeigen"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"Intent"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"Intent löschen"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"Vollbild-Intent"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"Aktionen"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"Titel"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"Eingaben aus der Ferne"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"Benutzerdefinierte Ansicht"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"Extras"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"Symbol"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"Größe des Pakets"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"Benachrichtigungsalarm"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"Kanal"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Das Rangobjekt fehlt."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Dieser Schlüssel ist in dem Rangobjekt nicht enthalten."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Display-Aussparung"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"display aussparung, notch"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Gemäß Standard fürs Gerät"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Overlay konnte nicht angewendet werden"</string>
    <string name="special_access" msgid="1767980727423395147">"Spezieller App-Zugriff"</string>
    <plurals name="special_access_summary" formatted="false" msgid="4995506406763570815">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> Apps dürfen uneingeschränkt Daten nutzen</item>
      <item quantity="one">1 App darf uneingeschränkt Daten nutzen</item>
    </plurals>
    <string name="special_access_more" msgid="132919514147475846">"Mehr anzeigen"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Lange Hintergrundaufgaben"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Lang andauernde Hintergrundaufgaben erlauben"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Lange Hintergrundaufgaben"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Damit kannst du dieser App erlauben, lang andauernde Hintergrundaufgaben auszuführen. Die App kann dann Aufgaben ausführen, die länger als ein paar Minuten dauern, etwa Downloads und Uploads. \n\nWenn diese Berechtigung nicht gewährt wird, wird durch das System begrenzt, wie lange die App solche Aufgaben im Hintergrund ausführen darf."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"lang andauernde Aufgaben, Datenübertragung, Hintergrundaufgaben"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Limits für ShortcutManager-Aufrufe zurücksetzen"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Limits für ShortcutManager-Aufrufe zurückgesetzt"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Infos auf Sperrbildschirm festlegen"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Benachrichtigungsinhalt ein- oder ausblenden"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Tipps &amp; Support"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Geringste Breite"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Keine installierte App hat Zugriff auf Premium-SMS angefordert."</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Bei Premium-SMS können Kosten entstehen, die über den Mobilfunkanbieter abgerechnet werden. Wenn du für eine App Premium-SMS zulässt, kannst du aus ihr Premium-SMS versenden."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Zugriff auf Premium-SMS"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Aus"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Mit <xliff:g id="ID_1">%1$s</xliff:g> verbunden"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Mit mehreren Geräten verbunden"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Demomodus der System-UI"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Dunkles Design"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Wegen Energiesparmodus vorübergehend deaktiviert"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Wegen Energiesparmodus vorübergehend deaktiviert"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Energiesparmodus ausschalten"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Wegen Energiesparmodus vorübergehend aktiviert"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Dunkles Design testen"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Verlängert die Akkulaufzeit"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Kacheln für Schnelleinstellungen für Entwickler"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Zeitlimit für ADB-Autorisierung deaktivieren"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Automatische Aufhebung von ADB-Autorisierungen für Systeme deaktivieren, die sich nicht innerhalb der Standardzeit (7 Tage) oder der vom Nutzer festgelegten Zeit (mindestens 1 Tag) wieder verbunden haben."</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Winscope Trace"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Sensoren aus"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Einstellungen für Arbeitsprofil"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"In privaten Apps nach Verzeichniskontakten deiner Arbeit suchen"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Deine Suchanfragen und eingehende Anrufe können für deinen IT-Administrator sichtbar sein"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Profilübergreifender Kalender"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Geschäftliche Termine in meinem persönlichen Kalender anzeigen"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Wenn geschäftliche Apps ausgeschaltet sind, sind sie pausiert, d. h., weder kannst du darauf zugreifen noch erhältst du Benachrichtigungen"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Speicher verwalten"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Zur Freigabe von Speicherplatz entfernt der Speichermanager Back-ups von Fotos und Videos von deinem Gerät."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Fotos &amp; Videos entfernen"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Speichermanager"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Speichermanager verwenden"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gesten und Bewegungen"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Kamera schnell öffnen"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Ein-/Aus-Taste zweimal drücken, um Kamera direkt zu starten. Funktioniert auch, wenn eine andere App geöffnet ist."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Für Selfie-Modus Handgelenk drehen"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Navigationsmodus"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Bedienung über 2 Schaltflächen"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Wenn du zwischen Apps wechseln möchtest, wische auf der Startbildschirmtaste nach oben. Wische noch einmal nach oben, um alle Apps zu sehen. Tippe auf die Schaltfläche \"Zurück\", um zurückzugehen."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Sicherheit und Notfälle"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Notfall-SOS, medizinische Informationen, Benachrichtigungen"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Bedienung über Gesten"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"Öffne den Startbildschirm, indem du vom unteren Bildschirmrand nach oben wischst. Wenn du zwischen Apps wechseln möchtest, wische von unten nach oben, halte den Finger gedrückt und lass ihn dann los. Wenn du zurückgehen möchtest, wische vom linken oder vom rechten Rand nach innen."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Bedienung über 3 Schaltflächen"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Nutze die Schaltflächen unten auf deinem Bildschirm, um zurückzugehen, den Startbildschirm aufzurufen und zwischen Apps zu wechseln."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"Systemsteuerung, Bedienung über 2 Schaltflächen, Bedienung über 3 Schaltflächen, Gestensteuerung, Bedienung über Gesten, wischen"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digitaler Assistent"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Zum Öffnen des Assistenten wischen"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Wische von einer unteren Ecke nach oben, um die App für den digitalen Assistenten aufzurufen."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Aufrufen von Assistant per Drücken der Startbildschirmtaste"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Halte die Startbildschirmtaste gedrückt, um die App für den digitalen Assistenten aufzurufen."</string>
    <string name="low_label" msgid="6525629096999711220">"Niedrig"</string>
    <string name="high_label" msgid="357503396626018487">"Hoch"</string>
    <string name="left_edge" msgid="1513576842959071849">"Linker Rand"</string>
    <string name="right_edge" msgid="1505309103265829121">"Rechter Rand"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Wenn du die Empfindlichkeit erhöhst, werden eventuell App-spezifische Touch-Gesten am Bildschirmrand beeinträchtigt."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Empfindlichkeit bei Touch-Geste „Zurück“"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Empfindlichkeit der Bedienung über Gesten"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Bedienung über Schaltflächen"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"bedienung über gesten, gestensteuerung, gestenbedienung, empfindlichkeit bei touch-geste zurück, empfindlichkeit geste zurück, empfindlichkeit zurückgeste, touch-geste zurück, geste zurück, zurückgeste"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigation, bedienung, startbildschirmtaste, taste in der mitte, home-taste, home button"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Einhandmodus"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Einhandmodus verwenden"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Kurzbefehl für Einhandmodus"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"Einhandbedienung"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Beim Wischen nach unten…"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Tastenkombination für Folgendes verwenden:"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Ziehe die obere Hälfte des Bildschirms nach unten, damit du sie leichter mit einer Hand erreichen kannst"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"So verwendest du den Einhandmodus"</b>\n" • Achte darauf, dass in den Einstellungen für die Systemnavigation die Bedienung über Gesten ausgewählt ist.\n • Wische am unteren Bildschirmrand nach unten."</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Display nach unten ziehen"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Der obere Bereich des Displays wird nach unten verschoben, sodass du ihn mit dem Daumen bequem erreichst."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Benachrichtigungen anzeigen"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Benachrichtigungen und Einstellungen werden angezeigt."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Wenn du auf den Bildschirm doppeltippst, werden die Uhrzeit, Benachrichtigungen und andere Informationen angezeigt."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Bildschirm aktivieren"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Wenn du auf den Bildschirm tippst, werden die Uhrzeit, Benachrichtigungen und andere Informationen angezeigt."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Notfall-SOS"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Notfall-SOS-Funktion verwenden"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Die Ein-/Aus-Taste fünfmal oder öfter kurz hintereinander drücken, um die Aktionen unten zu starten"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Countdown-Alarm abspielen"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Durch einen lauten Signalton verdeutlichen, dass ein Notfall-SOS-Anruf gestartet wird"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Um Hilfe bitten"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Hilfe anfordern"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Notrufnummer"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Zum Ändern tippen"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Wenn du eine beliebige Nummer (keine Notrufnummer) eingibst:\n • Dein Gerät muss entsperrt sein, damit du die Notfall-SOS-Funktion nutzen kannst\n • Dein Anruf wird möglicherweise nicht angenommen"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Benachrichtigungen durch Wischen über Fingerabdrucksensor einblenden"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Fingerabdruck­sensor verwenden"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Benachrichtigungen schnell ansehen"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"An"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Aus"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Bootloader ist bereits entsperrt"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Internetverbindung herstellen oder Mobilfunkanbieter kontaktieren"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Auf vom Mobilfunkanbieter gesperrten Geräten nicht verfügbar"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Starte das Gerät neu, um die Geräteschutzfunktion zu aktivieren."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Insgesamt <xliff:g id="SIZE">%1$s</xliff:g> freigegeben\n\nZuletzt ausgeführt am <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Instant Apps"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Links in Apps öffnen, ohne dass die Apps dazu installiert sein müssen"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Instant Apps"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Instant Apps-Einstellungen"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Installierte Apps"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Dein Speicher wird jetzt vom Speichermanager verwaltet"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Konten für <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"App-Daten automatisch synchronisieren"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Apps die automatische Aktualisierung von Daten erlauben"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Kontosynchronisierung"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Synchronisierung für <xliff:g id="ID_1">%1$d</xliff:g> von <xliff:g id="ID_2">%2$d</xliff:g> Elementen aktiviert"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Synchronisierung für alle Elemente aktiviert"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Synchronisierung für alle Elemente deaktiviert"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Info zu verwalteten Geräten"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Änderungen und Einstellungen, die von deiner Organisation verwaltet werden"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Änderungen und Einstellungen, die von <xliff:g id="ORGANIZATION_NAME">%s</xliff:g> verwaltet werden"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Um dir Zugriff auf deine Arbeitsdaten zu geben, kann deine Organisation Einstellungen ändern und Software auf deinem Gerät installieren.\n\nWeitere Informationen erhältst du vom Administrator deiner Organisation."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Art von Informationen, die deine Organisation sehen kann"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Änderungen des Administrators deiner Organisation"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Mein Zugriff auf dieses Gerät"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Daten zum Arbeitskonto, etwa E-Mail und Kalender"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Liste der Apps auf dem Gerät"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Nutzungsdauer und genutzte Datenmenge für jede App"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Neuestes Protokoll zum Netzwerkverkehr"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Neuester Fehlerbericht"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Neuestes Sicherheitsprotokoll"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Keine"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Installierte Apps"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Die Anzahl der Apps ist eine Schätzung. Darin sind möglicherweise nicht die installierten Apps enthalten, die nicht aus dem Play Store stammen."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Mindestens # App}other{Mindestens # Apps}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Standortberechtigungen"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Mikrofonberechtigungen"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Kameraberechtigungen"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Standard-Apps"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# App}other{# Apps}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Standardtastatur"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Auf <xliff:g id="APP_LABEL">%s</xliff:g> eingestellt"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Durchgehend aktives VPN wurde aktiviert"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Durchgehend aktives VPN wurde für dein persönliches Profil aktiviert"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Durchgehend aktives VPN wurde für dein Arbeitsprofil aktiviert"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Globaler HTTP-Proxy wurde eingerichtet"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Vertrauenswürdige Anmeldedaten"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Vertrauenswürdige Anmeldedaten in deinem privaten Profil"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Vertrauenswürdige Anmeldedaten in deinem Arbeitsprofil"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Mindestens # CA-Zertifikat}other{Mindestens # CA-Zertifikate}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Der Administrator kann das Gerät sperren und das Passwort zurücksetzen"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Der Administrator kann alle Gerätedaten löschen"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Anzahl falscher Passworteingaben, bevor alle Gerätedaten gelöscht werden"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Anzahl falscher Passworteingaben, bevor die Arbeitsprofildaten gelöscht werden"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# Versuch}other{# Versuche}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Dieses Gerät wird von deiner Organisation verwaltet."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Dieses Gerät wird von <xliff:g id="ORGANIZATION_NAME">%s</xliff:g> verwaltet."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Weitere Informationen"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Eingeschränkte Einstellung"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Eingeschränkte Einstellungen zugelassen für <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Aus Sicherheitsgründen ist diese Einstellung derzeit nicht verfügbar."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Info zu finanzierten Geräten"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Dein Kreditinstitut kann während der Einrichtung auf diesem Gerät Einstellungen ändern und Software installieren.\n\nWenn du nicht rechtzeitig bezahlst, kann das Kreditinstitut dein Gerät sperren und die Einstellungen ändern.\n\nWeitere Informationen erhältst du bei deinem Kreditinstitut."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Bei finanzierten Geräten ist Folgendes nicht möglich:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Apps aus anderen Quellen als dem Play Store installieren"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Dein Gerät im abgesicherten Modus neu starten"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Deinem Gerät mehrere Nutzer hinzufügen"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Datum, Uhrzeit und Zeitzonen ändern"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Entwickleroptionen verwenden"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Dein Kreditinstitut kann Folgendes tun:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Auf deine IMEI-Nummer zugreifen"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Dein Gerät auf die Werkseinstellungen zurücksetzen, wenn Probleme auftreten"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Wenn das Gerät gesperrt ist, kannst du es nur für Folgendes verwenden:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Notrufnummern anrufen"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Systeminformationen wie Datum, Uhrzeit, Netzwerkstatus und Akkustand aufrufen"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Gerät ein- oder ausschalten"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Benachrichtigungen und SMS aufrufen"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Auf Apps zugreifen, die vom Kreditinstitut zugelassen sind"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Nach Zahlung des gesamten Betrags geschieht Folgendes:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Alle Beschränkungen werden vom Gerät entfernt"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Du kannst die App des Kreditinstituts deinstallieren"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Informationen zu finanzierten Geräten"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Kamera-App}other{Kamera-Apps}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Kalender-App"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Kontakte App"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{E-Mail-Client-App}other{E-Mail-Client-Apps}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Karten-App"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Telefon-App}other{Telefon-Apps}}"</string>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g> und <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="7019703249717854148">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g> und <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_default_internal_storage" msgid="4055660218818688131">"Dieses Gerät"</string>
    <string name="storage_games" msgid="1176568610086802469">"Spiele"</string>
    <string name="storage_files" msgid="7968460921272772299">"Dateien"</string>
    <string name="storage_images" msgid="2055893015567979387">"Bilder"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videos"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Audio"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Apps"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumente und Sonstiges"</string>
    <string name="storage_system" msgid="8472410119822911844">"System"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Papierkorb"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Papierkorb leeren?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Im Papierkorb befinden sich <xliff:g id="TOTAL">%1$s</xliff:g> Dateien. Alle Elemente werden endgültig gelöscht und du kannst sie nicht wiederherstellen."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Der Papierkorb ist leer"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Papierkorb leeren"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> belegt"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"Insgesamt <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"App löschen"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Möchtest du diese Instant App entfernen?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Öffnen"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Spiele"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Belegter Speicherplatz"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(für Nutzer <xliff:g id="USER">%s</xliff:g> deinstalliert)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(für Nutzer <xliff:g id="USER">%s</xliff:g> deaktiviert)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Autofill-Service"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Standard-Autofill-Service"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Passwörter"</string>
    <string name="credman_chosen_app_title" msgid="4547405511458518096">"Passwörter, Passkeys und Datendienste"</string>
    <string name="credman_credentials" msgid="4931371941253324143">"Zusätzliche Anbieter"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# Passwort}other{# Passwörter}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automatisch, füllen, ausfüllen, Passwort, auto, fill, autofill, password"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"Daten, Passkey, Passwort"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"automatisch, ausfüllen, Autofill, Daten, Passkey, Passwort"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Nur für vertrauenswürdige Apps&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google Autofill&gt;%1$s&lt;/xliff:g&gt; greift auf die Displayanzeige zu, um zu bestimmen, welche Felder automatisch ausgefüllt werden können. Die Funktion sollte daher nur für vertrauenswürdige Apps zugelassen werden."</string>
    <string name="credman_autofill_confirmation_message" msgid="4951846866327737417">"&lt;b&gt;&lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; verwenden?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; bestimmt anhand des Bildschirminhalts, was automatisch ausgefüllt werden kann. Ab jetzt werden neue Passwörter, Passkeys und andere Informationen hier gespeichert."</string>
    <string name="credman_picker_title" msgid="2642776965060619988">"Passwörter, Passkeys und Datendienste"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"%1$s deaktivieren?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Diesen Dienst deaktivieren?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Gespeicherte Daten wie Passwörter, Passkeys, Zahlungsmethoden usw. werden beim Anmelden nicht eingetragen. Wenn du deine gespeicherten Daten verwenden möchtest, nutze einen Passwort-, Passkey- oder Datendienst."</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"%1$s verwenden?"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s ermittelt anhand der Inhalte auf deinem Bildschirm, welche Informationen automatisch ausgefüllt werden können."</string>
    <string name="credman_error_message_title" msgid="4741457523969373713">"Beschränkung für Passwörter, Passkeys und Datendienste"</string>
    <string name="credman_error_message" msgid="6793314648458925172">"Es können bis zu 5 Passwörter, Passkeys und Datendienste gleichzeitig aktiviert sein. Wenn du einen weiteren Dienst hinzufügen möchtest, deaktiviere einen anderen."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Deaktivieren"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Autofill"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Protokollierungsebene"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Maximale Zahl von Anfragen pro Sitzung"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Maximale Zahl sichtbarer Datensätze"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Auf Standardwerte zurücksetzen"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Die Autofill-Optionen für Entwickler wurden zurückgesetzt"</string>
    <string name="location_category" msgid="3496759112306219062">"Standort"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Standortanzeige in der Statusleiste"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Für alle Standorte anzeigen, einschließlich Netzwerk und Verbindung"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Vollständige GNSS-Messung erzwingen"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Alle GNSS-Konstellationen und -Frequenzen durchgehend erfassen"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Eingabemethode"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Schreiben mit Eingabestift"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Ist diese Option aktiviert, empfängt die aktuelle Eingabemethode ein Eingabestift-MotionEvent, wenn ein Editor fokussiert wird."</string>
    <string name="device_theme" msgid="5027604586494772471">"Gerätedesign"</string>
    <string name="default_theme" msgid="4815428567082263639">"Standard"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Netzwerkname"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Netzwerkname in Statusleiste anzeigen"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Instant App"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Speichermanager deaktivieren?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"„Bitte nicht stören“ aktualisieren"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Zur besseren Konzentration Benachrichtigungen pausieren"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funktion nicht verfügbar"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Diese Funktion wurde deaktiviert, weil sie dein Smartphone langsamer macht"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Bei Absturz immer Absturz-Dialogfeld anzeigen"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Bei App-Abstürzen immer Dialogfeld anzeigen"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"ANGLE-App auswählen"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Keine ANGLE-App festgelegt"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"ANGLE-App: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Grafiktreiber-Einstellungen"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Grafiktreiber-Einstellungen ändern"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Wenn es mehrere Grafiktreiber gibt, kannst du für Apps auf diesem Gerät den aktualisierten Grafiktreiber nutzen."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Für alle Apps aktivieren"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Grafiktreiber auswählen"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Standard"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Game Driver"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Entwickler-Treiber"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Grafiktreiber des Systems"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="enable_angle_as_system_driver" msgid="3985105681812713612">"ANGLE aktivieren"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="4173041926052925436">"ANGLE als OpenGL ES-Systemtreiber aktivieren"</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Ein Neustart ist erforderlich, um den OpenGL ES-Systemtreiber zu ändern"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Änderungen der Kompatibilität von Apps"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Änderungen bei der Kompatibilität von Apps festlegen"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Standardmäßig aktivierte Änderungen"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Standardmäßig deaktivierte Änderungen"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"Keine Apps verfügbar"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Die Kompatibilität kann nur bei debug-fähigen Apps geändert werden. Installiere eine debug-fähige App und versuch es noch einmal."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Hängt von einer anderen Einstellung ab"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Konto"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Gerätename"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Allgemeine Informationen"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Rechtliche Informationen"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Gerätedetails"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Geräte-IDs"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"WLAN-Steuerung"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"App darf WLAN steuern"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Erlaubt der App, das WLAN zu aktivieren oder zu deaktivieren, nach WLANs zu scannen und eine Verbindung zu ihnen herstellen, Netzwerke hinzuzufügen oder zu entfernen oder einen lokal beschränkten Hotspot zu starten"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Über NFC starten"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Start bei NFC-Scan erlauben"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Erlauben, dass diese App gestartet wird, wenn ein NFC-Tag gescannt wird.\nWenn Apps diese Berechtigung haben, stehen sie als Option zur Verfügung, wenn ein Tag erkannt wird."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Medien hier abspielen:"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"<xliff:g id="LABEL">%s</xliff:g> abspielen über"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Dieses Gerät"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Während Anrufen nicht verfügbar"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Anruf annehmen auf"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Dieser APN kann nicht geändert werden."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Klingeln verhindern"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Drücken der „Ein/Aus“- + „Lauter“-Taste ersetzt Klingeln durch"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Klingeln per Tastendruck verhindern"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibrieren"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Stummschalten"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibrieren"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Stummschalten"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Ändere zum Aktivieren erst „Ein-/Aus-Taste gedrückt halten“ zu „Ein-/Aus-Menü“."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Netzwerkdetails"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"Dein Gerätename ist für Apps auf deinem Smartphone sichtbar. Wenn du dein Gerät mit Bluetooth-Geräten oder einem WLAN verbindest oder einen WLAN-Hotspot einrichtest, kann der Name möglicherweise auch von anderen Personen gesehen werden."</string>
    <string name="devices_title" msgid="649715719278562515">"Geräte"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Netzwerk auswählen"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Nicht verbunden"</string>
    <string name="network_connected" msgid="7637745547242487795">"Verbunden"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Verbindung wird hergestellt…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Verbindung nicht möglich"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Keine Netzwerke gefunden."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Netzwerke nicht gefunden. Bitte versuch es noch einmal."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(nicht zulässig)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Keine SIM-Karte"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Keine"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Zum Herstellen einer Verbindung ist eine SIM-Karte erforderlich"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Zum Herstellen einer Verbindung ist eine <xliff:g id="WIRELESS_CARRIER">%s</xliff:g>-SIM-Karte erforderlich"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Bevorzugter Netzmodus: WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Bevorzugter Netzmodus: nur GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Bevorzugter Netzmodus: nur WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Bevorzugter Netzmodus: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Bevorzugter Netzmodus: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Bevorzugter Netzmodus: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Bevorzugter Netzmodus: nur CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Bevorzugter Netzmodus: nur EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Bevorzugter Netzmodus: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Bevorzugter Netzmodus: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Bevorzugter Netzmodus: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Bevorzugter Netzmodus: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Bevorzugter Netzmodus: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Bevorzugter Netzmodus: global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Bevorzugter Netzmodus: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Bevorzugter Netzmodus: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Bevorzugter Netzmodus: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Bevorzugter Netzmodus: TD-SCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Bevorzugter Netzmodus: TD-SCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Bevorzugter Netzmodus: LTE/TD-SCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Bevorzugter Netzmodus: TD-SCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Bevorzugter Netzmodus: LTE/GSM/TD-SCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Bevorzugter Netzmodus: TD-SCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Bevorzugter Netzmodus: LTE/TD-SCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Bevorzugter Netzmodus: LTE/TD-SCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Bevorzugter Netzmodus: TD-SCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Bevorzugter Netzmodus: LTE/TD-SCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Bevorzugter Netzmodus: nur NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Bevorzugter Netzmodus: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Bevorzugter Netzmodus: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Bevorzugter Netzmodus: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Bevorzugter Netzmodus: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Bevorzugter Netzmodus: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Bevorzugter Netzmodus: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Bevorzugter Netzmodus: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Bevorzugter Netzmodus: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Bevorzugter Netzmodus: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Bevorzugter Netzmodus: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (empfohlen)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (empfohlen)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (empfohlen)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Netz automatisch auswählen"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Mobilfunkanbieter-Einstellungen"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Datendienst einrichten"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobile Daten"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Datenzugriff über Mobilfunknetz"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefon wechselt automatisch zu diesem Mobilfunkanbieter, wenn er in Reichweite ist"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Keine SIM verfügbar"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Anrufeinstellung"</string>
    <string name="sms_preference" msgid="7742964962568219351">"SMS-Einstellung"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Jedes Mal fragen"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Netzwerk hinzufügen"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Standardeinstellung für Anrufe"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Standardeinstellung für SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Standardeinstellung für Anrufe und SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Standardeinstellung für mobile Daten"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Mobile Datennutzung aktiviert"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobile Datennutzung deaktiviert"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Verfügbar"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"SIM-Karte hinzufügen"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktiv/SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Inaktiv/SIM"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Aktiv/eSIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Inaktiv/eSIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"SIM-Name und -Farbe"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Name"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Farbe (verwendet von kompatiblen Apps)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Speichern"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"SIM verwenden"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Aus"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"SIM-Karte entfernen, um sie zu deaktivieren"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Zum Aktivieren von <xliff:g id="CARRIER">%1$s</xliff:g> tippen"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"SIM löschen"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Bevorzugter Netztyp"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Netzmodus ändern"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Bevorzugter Netztyp"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Version der Mobilfunkanbieter-Einstellungen"</string>
    <string name="call_category" msgid="641461844504128789">"Anruffunktionen"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Videoanrufe über Mobilfunkanbieter"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Systemauswahl"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"CDMA-Roamingmodus ändern"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Systemauswahl"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Mobilfunknetz"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA-Abo"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Zwischen RUIM/SIM und NV wechseln"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"Abo"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automatische Registrierung…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Daten-Roaming zulassen?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Wenn du Informationen zu Preisen erhalten möchtest, wende dich bitte an deinen Netzwerkanbieter."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Datennutzung durch Apps"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Ungültiger Netzmodus <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignorieren."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Zugangspunkte (APNs)"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"APN"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Bei Verbindung mit <xliff:g id="CARRIER">%1$s</xliff:g> nicht verfügbar"</string>
    <string name="see_more" msgid="7499355691042812723">"Mehr anzeigen"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> aktivieren?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"SIM aktivieren?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Zu <xliff:g id="CARRIER_NAME">%1$s</xliff:g> wechseln?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"SIM-Karte wechseln?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> verwenden?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Es kann immer nur eine SIM-Karte aktiv sein.\n\nDein Mobilfunkvertrag bei <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g> wird nicht gekündigt, wenn du zu <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> wechselst."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="8977951796005849471">"Es kann immer nur eine eSIM aktiv sein.\n\nDein Mobilfunkvertrag bei <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g> wird nicht gekündigt, wenn du zu <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> wechselst."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Es kann immer nur eine SIM-Karte aktiv sein.\n\nDein Mobilfunkvertrag bei <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> wird nicht gekündigt, wenn du die SIM-Karte wechselst."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Du kannst 2 SIMs gleichzeitig verwenden. Wenn du <xliff:g id="CARRIER_NAME">%1$s</xliff:g> verwenden möchtest, musst du eine andere SIM deaktivieren."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Zu <xliff:g id="CARRIER_NAME">%1$s</xliff:g> wechseln"</string>
    <string name="sim_action_switch_sub_dialog_carrier_list_item_for_turning_off" msgid="5392037608705799522">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> deaktivieren"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Wenn du eine SIM deaktivierst, wird dein Mobilfunkvertrag nicht gekündigt"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Verbindung zum Mobilfunknetz wird hergestellt…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Für Anrufe und Nachrichten wird zu <xliff:g id="CARRIER_NAME">%1$s</xliff:g> gewechselt…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Mobilfunkanbieter kann nicht gewechselt werden"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Der Mobilfunkanbieter kann aufgrund eines Fehlers nicht gewechselt werden."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> deaktivieren?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"SIM deaktivieren?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"SIM wird deaktiviert<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Mobilfunkanbieter kann nicht deaktiviert werden"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Ein Problem ist aufgetreten. Dein Mobilfunkanbieter konnte nicht deaktiviert werden."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Zwei SIM-Karten verwenden?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Auf diesem Gerät können zwei SIM-Karten gleichzeitig aktiv sein. Wenn du weiterhin nur eine SIM-Karte verwenden möchtest, tippe auf „Nein danke“."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Gerät neu starten?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Ja"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Neu starten"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Nein danke"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Abbrechen"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Wechseln"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"SIM kann nicht aktiviert werden"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Versuche, die SIM noch einmal zu aktivieren. Sollte das Problem weiterhin bestehen, starte das Gerät neu."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Netzwerkaktivierung"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Wechsel des Mobilfunkanbieters"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> ist aktiviert"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Tippe, um die SIM-Einstellungen zu aktualisieren"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Zu <xliff:g id="CARRIER_NAME">%1$s</xliff:g> gewechselt"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Zu einem anderen Mobilfunkanbieter gewechselt"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Dein Mobilfunknetz hat sich geändert"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Andere SIM-Karte einrichten"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Du kannst die aktive SIM-Karte auswählen oder zwei SIM-Karten gleichzeitig verwenden"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Nummer für die Nutzung auswählen"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{Auf diesem Gerät ist 1 Nummer verfügbar und es kann jeweils nur eine verwendet werden}=2{Auf diesem Gerät sind 2 Nummern verfügbar, es kann aber jeweils nur eine verwendet werden}other{Auf diesem Gerät sind # Nummern verfügbar, es kann aber jeweils nur eine verwendet werden}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Wird aktiviert<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Kann momentan nicht aktiviert werden"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> verwenden?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"Für mobile Daten, Anrufe und SMS wird <xliff:g id="CARRIER_NAME">%1$s</xliff:g> verwendet."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Keine aktiven SIM-Karten verfügbar"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Wenn du mobile Daten, Anruffunktionen und SMS später einrichten möchtest, kannst du das in deinen Netzwerkeinstellungen tun"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Diese eSIM löschen?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Wenn du diese SIM löschst, wird der <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g>-Dienst von diesem Gerät entfernt.\n\nDer Mobilfunkvertrag bei <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> wird dadurch nicht gekündigt."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Löschen"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"SIM wird gelöscht…"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"SIM kann nicht gelöscht werden"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"Beim Löschen der SIM ist ein Fehler aufgetreten.\n\nBitte starte dein Gerät neu und versuch es dann noch einmal."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Mit Gerät verbinden"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Die App „<xliff:g id="APPNAME">%1$s</xliff:g>“ möchte sich über ein temporäres WLAN mit deinem Gerät verbinden"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Keine Geräte gefunden. Achte darauf, dass die Geräte eingeschaltet und zur Verbindung bereit sind."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Noch einmal versuchen"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Ein Fehler ist aufgetreten. Die Anwendung hat die Anfrage zur Auswahl eines Geräts abgebrochen."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Verbindung hergestellt"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Verbindung fehlgeschlagen"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Alle anzeigen"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Gerät wird gesucht…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Verbindung mit Gerät wird hergestellt…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Links"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Rechts"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Etui"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Einstellungen"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Desktop-Modus erzwingen"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Experiementellen Desktop-Modus auf sekundären Bildschirmen erzwingen"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Mehrfenstermodus für nicht änderbare Größen aktivieren"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Erlaubt Mehrfenstermodus für Apps mit nicht änderbarer Größe"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Erzwingen des dunklen Modus außer Kraft setzen"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Apps werden nicht gezwungen, den dunklen Modus zu verwenden"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Datenschutz"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Berechtigungen, Kontoaktivität, personenbezogene Daten"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Einstellungen"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Entfernen"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Behalten"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Diesen Vorschlag entfernen?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Geringer Speicherplatz: <xliff:g id="PERCENTAGE">%1$s</xliff:g> belegt – <xliff:g id="FREE_SPACE">%2$s</xliff:g> frei"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Feedback senden"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Möchtest du uns zu diesem Vorschlag Feedback geben?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> in die Zwischenablage kopiert."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Nutzung der Bedienungshilfen"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 App hat uneingeschränkten Zugriff auf dein Gerät}other{# Apps haben uneingeschränkten Zugriff auf dein Gerät}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Wichtige Informationen"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"WEITER"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NEIN DANKE"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Ort"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Dein Mobilfunkanbieter kann deinen Standort erfassen, wenn du diesen Dienst für Notrufe verwendest.\n\nSieh dir für Details die Datenschutzerklärung deines Mobilfunkanbieters an."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Möglicherweise verlierst du den Zugriff auf ggf. verbliebene Zeit- oder Datenkontingente. Wende dich deswegen vor dem Entfernen an deinen Anbieter."</string>
    <string name="content_capture" msgid="868372905432812238">"App-Inhalte"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Apps erlauben, Inhalte an das Android-System zu senden"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"System-Heap-Dump erfassen"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Memory Tagging Extension"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"MTE (Memory Tagging Extension) vereinfacht die Ermittlung von Sicherheitsproblemen beim Speichern in deiner App und macht nativen App-Code sicherer."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Die Aktivierung von MTE kann das Gerät verlangsamen."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Weitere Informationen über MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"MTE bis zur Deaktivierung aktiviert lassen"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Du musst dein Gerät neu starten, um MTE zu aktivieren."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Du musst dein Gerät neu starten, um MTE zu deaktivieren."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"MTE für eine einzelne Sitzung aktivieren"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Das System wird neu gestartet und du kannst dann MTE (Memory Tagging Extension) testen. MTE kann die Leistung und Stabilität des Systems beeinträchtigen. Beim nächsten Neustart wird die Einstellung zurückgesetzt."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Für eine einzelne Sitzung mit aktivierter MTE neu starten"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"MTE ist bereits aktiviert"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"System-Heap-Dump wird erfasst"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"System-Heap-Dump konnte nicht erfasst werden"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"System-Heap-Dumps automatisch erfassen"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Bei zu hohem Speicherverbrauch automatisch Heap-Dump für das Android-System erfassen"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Trennen"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Notrufe"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Notrufe über WLAN-Telefonie werden von deinem Mobilfunkanbieter nicht unterstützt.\nDas Gerät wechselt automatisch zu einem Mobilfunknetz, um einen Notruf abzusetzen.\nNotrufe sind nur in Bereichen mit Mobilfunkabdeckung möglich."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Für Anrufe WLAN verwenden, um die Qualität zu verbessern"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Back-up für Anrufe"</string>
    <string name="backup_calling_setting_summary" msgid="599493254305348733">"Wenn <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> oder Roaming nicht verfügbar ist, kannst du über deine SIM für mobile Daten <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g>-Anrufe starten und annehmen."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"Back-up für Anrufe"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Eingehende MMS"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"MMS kann nicht gesendet werden"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Tippen, um MMS über <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> zuzulassen, wenn mobile Daten deaktiviert sind"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problem mit der SIM-Kombination"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Bei Verwendung von <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> sind u. U. nicht alle Funktionen verfügbar. Für weitere Informationen tippen."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"SIM-Kombination"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Informationen zu den Arbeitsrichtlinien"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Einstellungen, die von deinem IT-Administrator verwaltet werden"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Fehlerbericht-Handler"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Bestimmt, welche App die Verknüpfung zum Fehlerbericht auf deinem Gerät verarbeitet"</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Persönlich"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Arbeit"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"System-Standard­einstellung"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Keine"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Diese Auswahl ist nicht mehr gültig. Bitte versuch es noch einmal."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Ein-/Aus-Taste gedrückt halten"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Für Zugriff Ein-/Aus-Taste gedrückt halten"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Ein-/Aus-Menü"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Digitaler Assistent"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Auf digitalen Assistenten zugreifen"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Auf Ein-/Aus-Menü zugreifen"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Lege zuerst eine Displaysperre fest, damit du die Option verwenden kannst"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Ein-/Aus-Menü:\nEin-/Aus-Taste und Lautertaste gleichzeitig drücken"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Klingeln verhindern:\nFür Verknüpfung eine Lautstärketaste drücken"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Dauer des Gedrückthaltens"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Stelle die Empfindlichkeit ein, indem du festlegst, wie lange du die Ein-/Aus-Taste gedrückt halten musst"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Kurz"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Lang"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Wallet anzeigen"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Erlaubt den Zugriff auf Wallet auch im Sperrbildschirm."</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"QR-Code-Scanner anzeigen"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Zugriff auf QR-Code-Scanner vom Sperrbildschirm aus zulassen"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Gerätesteuerung anzeigen"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Über den Sperrbildschirm"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Gerätesteuerung nutzen"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Wenn du dies nutzen möchtest, aktiviere zuerst die Option „Gerätesteuerung anzeigen“"</string>
    <string name="lockscreen_double_line_clock_summary" msgid="2916159550425093703">"Uhrzeit in zwei Zeilen anzeigen, wenn verfügbar"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="3408639316001688529">"Uhrzeit in zwei Zeilen"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Verknüpfungen"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="one"><xliff:g id="FIRST_0">%1$s</xliff:g></item>
    </plurals>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"VoLTE deaktivieren?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Dadurch wird auch deine 5G-Verbindung deaktiviert.\nWährend eines Sprachanrufs kannst du das Internet nicht nutzen und manche Apps funktionieren möglicherweise nicht."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Ausführung für Apps im Cache aussetzen"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Läuft nicht ab."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Freigabe läuft niemals ab."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Apps dürfen über Einstellungen angezeigt werden"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Apps, die über anderen Apps angezeigt werden dürfen, dürfen auch über den Einstellungen angezeigt werden"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Mock Modem zulassen"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Erlaube diesem Gerät die Ausführung des Mock Modem-Dienstes für Instrumentierungstests. Aktiviere diese Funktion nicht während der normalen Nutzung des Smartphones."</string>
    <string name="media_controls_title" msgid="403271085636252597">"Medien"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Mediaplayer fixieren"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Damit die Wiedergabe schnell fortgesetzt werden kann, bleibt der Mediaplayer in den Schnelleinstellungen geöffnet"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Medien auf dem Sperrbildschirm anzeigen"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Damit die Wiedergabe schnell fortgesetzt werden kann, bleibt der Mediaplayer auf dem Sperrbildschirm geöffnet"</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Medienempfehlungen anzeigen"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Basierend auf deinen Aktivitäten"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Player ausblenden"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Player anzeigen"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"Medien"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth wird aktiviert"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM-Karten"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Anrufe &amp; SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"WLAN-Telefonie"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Anrufe über WLAN starten und empfangen"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Anrufe"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"bevorzugt"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"bevorzugt für Anrufe"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"bevorzugt für SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"nicht verfügbar"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Momentan nicht verfügbar"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Keine SIM-Karte"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Netzwerkeinstellungen"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"netzwerkverbindung, internet, kabellos, drahtlos, daten, wlan, w-lan, mobilfunk, mobil, mobilfunkanbieter, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Internetverbindung zurücksetzen?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Internetverbindung wird zurückgesetzt…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Konnektivitätsprobleme beheben"</string>
    <string name="networks_available" msgid="3299512933684383474">"Netzwerke verfügbar"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Trenne das Ethernetkabel, um das Netzwerk zu wechseln"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"W+-Verbindungen"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Google Fi erlauben, W+-Netzwerke zu verwenden, um die Geschwindigkeit und Abdeckung zu verbessern"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"W+-Netzwerk"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"eSIM"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"eSIMs"</string>
    <string name="sim_category_active_sim" msgid="1503823567818544012">"Aktiv"</string>
    <string name="sim_category_inactive_sim" msgid="4068899490133820881">"Inaktiv"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Standard für <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"Anrufe"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"mobile Daten"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Apps und Dienste können jederzeit nach WLANs suchen, auch wenn die WLAN-Funktion deaktiviert ist. Dadurch können beispielsweise standortbasierte Funktionen und Dienste verbessert werden. Das Verhalten lässt sich in den Einstellungen für die WLAN-Suche ändern."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Ändern"</string>
    <string name="preference_summary_default_combination" msgid="4643585915107796253">"<xliff:g id="STATE">%1$s</xliff:g> / <xliff:g id="NETWORKMODE">%2$s</xliff:g>"</string>
    <string name="mobile_data_connection_active" msgid="2422223108911581552">"Verbunden"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Vorübergehend verbunden"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Vorübergehend mit <xliff:g id="SUBNAME">%1$s</xliff:g> verbunden"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Keine Verbindung"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Automatische Verbindung zu mobilen Daten nicht möglich"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Mobile Daten deaktivieren?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Du kannst dann nicht mehr über <xliff:g id="CARRIER">%s</xliff:g> auf mobile Daten und das Internet zugreifen. Letzteres ist nur noch über WLAN möglich."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"deinen Mobilfunkanbieter"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Von deiner Organisation nicht zugelassen"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Nicht verfügbar, weil der Modus „Schlafenszeit“ aktiviert ist"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Die Wichtigkeit von Benachrichtigungen wurde zurückgesetzt."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Apps"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Ein Gerät fordert Zugriff auf deine Nachrichten an. Weitere Informationen."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Möchtest du den Zugriff auf Nachrichten zulassen?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Ein Bluetooth-Gerät (<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>) fordert Zugriff auf deine Nachrichten an.\n\nDein Gerät war bisher noch nicht mit <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> verbunden."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Ein Gerät fordert Zugriff auf deine Kontakte und deine Anrufliste an. Weitere Informationen."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Möchtest du den Zugriff auf Kontakte und Anrufliste zulassen?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Ein Bluetooth-Gerät (<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>) fordert Zugriff auf deine Kontakte und deine Anrufliste an. Dazu gehören auch Daten über ein- und ausgehende Anrufe.\n\nDein Gerät war bisher noch nicht mit <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> verbunden."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Helligkeit"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Displaysperre"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Darstellung"</string>
    <string name="category_name_color" msgid="937514550918977151">"Farbe"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Andere Displaysteuerelemente"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Allgemein"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Dunkles Design verwenden"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Bluetooth verwenden"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"„Klingeln verhindern“ verwenden"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"WLAN-Hotspot verwenden"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Bildschirmfixierung verwenden"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Entwickleroptionen verwenden"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Druckdienst verwenden"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Mehrere Nutzer zulassen"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"zulassen, mehrere, Nutzer, Erlaubnis, viele"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Debugging über WLAN verwenden"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Grafiktreiber-Einstellungen verwenden"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Nachtlicht verwenden"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"NFC verwenden"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Automatische Helligkeit verwenden"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"WLAN-Telefonie verwenden"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Alle Apps anzeigen"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Intelligente Weiterleitung"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Intelligente Weiterleitung aktiviert"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Intelligente Weiterleitung deaktiviert"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Anrufeinstellungen"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Einstellungen werden aktualisiert…"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Fehler bei Anrufeinstellungen"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Netzwerk- oder SIM-Fehler."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"SIM ist nicht aktiviert."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Telefonnummern eingeben"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Telefonnummer eingeben"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Telefonnummer fehlt."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"OK"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"2G zulassen"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G ist weniger sicher, bietet aber an manchen Standorten eine bessere Verbindung. Für Notrufe ist 2G immer zugelassen."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"Für <xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> muss 2G verfügbar sein"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Verschlüsselung erfordern"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Die Verschlüsselung ist sicherer, du kannst jedoch an manchen Standorten eventuell keine Verbindung herstellen. Für Notrufe ist eine Verschlüsselung nie erforderlich."</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Alle Dienste"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Zugriff auf Zwischenablage anzeigen"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Eine Meldung wird angezeigt, wenn Apps auf Text, Bilder oder andere Inhalte zugreifen, die du kopiert hast"</string>
    <string name="all_apps" msgid="3054120149509114789">"Alle Apps"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Nicht zulassen"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultrabreitband (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Zur Ermittlung der relativen Position von Geräten mit UWB in der Nähe"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Flugmodus deaktivieren, um UWB zu verwenden"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB ist an deinem derzeitigen Standort nicht verfügbar"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Kamerazugriff"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Mikrofonzugriff"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Für Apps und Dienste"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Für Apps und Dienste. Wenn diese Einstellung deaktiviert ist, können Mikrofondaten dennoch freigegeben werden, wenn du den Notruf wählst."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Zurück"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Weiter"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Farbvorschau"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"SIM-Zugriffsanfrage"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Ein Gerät möchte auf deine SIM zugreifen. Tippe, um weitere Informationen zu erhalten."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Zugriff auf SIM erlauben?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Das Bluetooth-Gerät „<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>“ möchte auf Daten auf deiner SIM zugreifen. Das betrifft auch deine Kontakte.\n\nSolange die Verbindung besteht, gehen alle Anrufe unter der Nummer <xliff:g id="PHONE_NUMBER">%3$s</xliff:g> an das Gerät „<xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>“."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Ein Bluetooth-Gerät ist verfügbar"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Ein Gerät möchte sich verbinden. Weitere Informationen."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Mit Bluetooth-Gerät verbinden?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> möchte sich mit diesem Smartphone verbinden.\n\nDu hast dich bisher nicht mit <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> verbunden."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Nicht verbinden"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Verbinden"</string>
    <string name="tare_settings" msgid="3788654800004869077">"TARE-Einstellungen"</string>
    <string name="tare_on" msgid="2386073225978684535">"An"</string>
    <string name="tare_off" msgid="6305694402929756726">"Aus"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Standardeinstellungen wiederherstellen"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Standardeinstellungen wiederhergestellt."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Maximale Balance bei voller Akkuladung"</string>
    <string name="tare_balances" msgid="731881382594747961">"Saldo"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Verbrauchslimits"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Anfängliches Verbrauchslimit"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Minimales Verbrauchslimit"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Maximales Verbrauchslimit"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modifikatoren"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Aktionen (Produktionskosten)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Aktionen (Grundpreis)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Prämien pro Ereignis"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Prämien pro Sekunde Ereignisdauer"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Maximale Anzahl von Prämien pro Tag"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"App-Installation"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Topaktivität"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Benachrichtigung gesehen"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Benachrichtigung nach max. 15 min gesehen"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Interaktion mit Benachrichtigung"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Interaktion mit Widget"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Andere Nutzerinteraktion"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Job-Start mit maximaler Priorität"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Job-Ausführung mit maximaler Priorität"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Job-Start mit hoher Priorität"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Job-Ausführung mit hoher Priorität"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Job-Standardstart"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Job-Standardausführung"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Job-Start mit geringer Priorität"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Job-Ausführung mit geringer Priorität"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Job-Start mit minimaler Priorität"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Job-Ausführung mit minimaler Priorität"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Job – Strafe für Zeitüberschreitung"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Mindestsaldo bei vollem Akku (vom Energiesparen ausgenommene Apps)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Mindestsaldo bei vollem Akku (System-App ohne Benutzeroberfläche)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Mindestsaldo bei vollem Akku (restliche Apps)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Ergänzung des Mindestsaldos bei vollem Akku (App-Updater)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Laden"</item>
    <item msgid="658627268149681677">"Stromsparmodus"</item>
    <item msgid="1599558140284643834">"Energiesparmodus"</item>
    <item msgid="588427840913221601">"Verarbeitungsstatus"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Bestätigen"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Vorschau anzeigen"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Bildschirmschoner auswählen"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Zusätzliche Informationen anzeigen"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Uhrzeit, Wetter oder andere Informationen auf dem Bildschirmschoner anzeigen"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Smart-Home-Steuerung anzeigen"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Schaltflächen zur Smart-Home-Steuerung auf dem Bildschirmschoner anzeigen lassen"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Weitere Einstellungen"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Bildschirmschoner auswählen"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Hier kannst du festlegen, was auf dem Display angezeigt werden soll, wenn das Tablet angedockt ist. Das Gerät verbraucht möglicherweise mehr Strom, wenn ein Bildschirmschoner verwendet wird."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Anpassen"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"<xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g> anpassen"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Damit die Freiform-Unterstützung aktiviert wird, musst du das Gerät neu starten."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Damit der Desktop-Modus auf sekundären Bildschirmen erzwungen wird, musst du das Gerät neu starten."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Jetzt neu starten"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Später neu starten"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Spatial Audio"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Klang von kompatiblen Medien wird noch voller"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Erfassung von Kopfbewegungen"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Änderungen am Ton, während du deinen Kopf bewegst, damit er natürlicher klingt"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Ratenbegrenzung für Downloads im Netzwerk"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Damit kannst du die Ratenbegrenzung für eingehenden Traffic über die Netzwerkbandbreite konfigurieren, die für alle Netzwerke angewendet wird, die eine Internetverbindung zur Verfügung stellen."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Ratenbegrenzung für Downloads im Netzwerk konfigurieren"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Keine Begrenzung"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Beschränkungen für Unterprozesse deaktivieren"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Beschränkungen für die Nutzung von Systemressourcen durch die untergeordneten App-Prozesse deaktivieren"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Funktion „Notizen“ zwingend aktivieren"</string>
    <string name="enable_notes_role_summary" msgid="136916915155048249">"Systemintegrationen für Notizen lassen sich über die Funktion „Notizen“ aktivieren. Ist die Funktion „Notizen“ schon aktiviert, passiert nichts."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Übertragen"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"<xliff:g id="CURRENTAPP">%1$s</xliff:g> streamen"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Du kannst dir das anhören, was andere in deiner Nähe abspielen"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Du kannst Medien auf Geräte in deiner Nähe übertragen oder dir das anhören, was andere übertragen"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Übertragungen"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Läuft gerade"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Übertragungen finden"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Übertragung verlassen"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"QR-Code scannen"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Passwort eingeben"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Verbindung nicht möglich. Versuche es noch einmal."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Falsches Passwort"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Teilnahme an der Übertragung nicht möglich"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Scanne zum Anhören den QR-Code unten"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"Das Format des QR-Codes ist ungültig"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"In eSIM umwandeln"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"eSIM auf ein anderes Gerät übertragen"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# App}other{# Apps}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Im Hintergrund installierte Apps"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Der Gerätehersteller kann im Hintergrund Apps auf deinem Gerät installieren oder deinem Mobilfunkanbieter und anderen Partnern die Berechtigung dazu erteilen.\n\nDie hier angezeigten Apps kannst du deinstallieren, ohne die Funktionsweise deines Geräts zu beeinträchtigen."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Es wurden keine Apps im Hintergrund installiert"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"App deinstallieren"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Apps, die innerhalb des letzten Monats installiert wurden}other{Apps, die innerhalb der letzten # Monate installiert wurden}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Apps, die vor mehr als # Monat installiert wurden}other{Apps, die vor mehr als # Monaten installiert wurden}}"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Fingerabdrucksensor"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Aufleuchten bei Benachrichtigungen"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Infos zum Aufleuchten bei Benachrichtigungen"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Aus"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"An / Aufleuchten des Kamerablitzes bei Benachrichtigungen"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"An / Aufleuchten des Bildschirms bei Benachrichtigungen"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"An / Kamerablitz und Bildschirm leuchten kurz auf"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Wenn du eine Benachrichtigung erhältst oder ein Wecker klingelt, leuchten der Kamerablitz oder der Bildschirm kurz auf"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Wenn du eine Benachrichtigung erhältst oder ein Wecker klingelt, leuchtet der Bildschirm kurz auf"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Wenn du lichtempfindlich bist, solltest du das Aufleuchten bei Benachrichtigungen mit Vorsicht verwenden"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"Blitz, Licht, schwerhörig, Hörverlust"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Vorschau"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Aufleuchten des Kamerablitzes bei Benachrichtigungen"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Aufleuchten des Bildschirms bei Benachrichtigungen"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Farbe des Bildschirms beim Aufleuchten"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Blau"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Himmelblau"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Cyan"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Frühlingsgrün"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Grün"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Hellgrün"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Gelb"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Orange"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Rot"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Pink"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Magenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Violett"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Fertig"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Abbrechen"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Mittel"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Hoch"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Diese App kann nur in einem einzigen Fenster geöffnet werden"</string>
</resources>
