<?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">"Nej"</string>
    <string name="create" msgid="986997212165228751">"Opret"</string>
    <string name="allow" msgid="3763244945363657722">"Tillad"</string>
    <string name="deny" msgid="7326117222944479942">"Afvis"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Aktivér"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Ukendt"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Tryk for at vise oplysninger"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Du er nu # skridt fra at være udvikler.}one{Du er nu # skridt fra at være udvikler.}other{Du er nu # skridt fra at være udvikler.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Nu er du udvikler!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Det behøver du ikke. Du er allerede udvikler."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Aktivér Indstillinger for udviklere først."</string>
    <string name="header_category_system" msgid="1665516346845259058">"System"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"I drift"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Ude af drift"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radioen er slukket"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Roamer ikke"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Afbrudt"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Forbinder"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Forbundet"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Sat på pause"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Ukendt"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Forhåndsvisning"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Formindsk"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Forstør"</string>
    <string name="stay_awake_on_fold_title" msgid="6590454679898134221">"Altid"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"Skærm på forsiden tændes, når du folder din enhed"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Kun spil, videoer m.m."</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"Skærmen på forsiden tændes i forbindelse med apps, der forhindrer din skærm i at blive inaktiv"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Aldrig"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"Skærmen på forsiden låses, når du folder din enhed"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Brug automatisk rotering"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Ansigtsgenkendelse bruger kameraet på forsiden for at forbedre nøjagtigheden af indstillingen Roter automatisk. Billeder gemmes ikke, og de sendes aldrig til Google."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Synlig for alle Bluetooth-enheder i nærheden (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Synlig for alle Bluetooth-enheder i nærheden"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Ikke synlig for andre Bluetooth-enheder"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Kun synlig for parrede enheder"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Bluetooth-enheder"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Enhedens navn"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Omdøb denne enhed"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Omdøb"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Afbryd forbindelse til enhed?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Par en ny enhed"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Par højre øre"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Par venstre øre"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Par det andet høreapparat"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Dit venstre høreapparat er tilsluttet.\n\nDu kan parre det højre ved at sørge for, at det er tændt og klar til at blive parret."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Dit højre høreapparat er tilsluttet.\n\nDu kan parre det venstre ved at sørge for, at det er tændt og klar til at blive parret."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Par højre apparat"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Par venstre apparat"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"For alle tilgængelige høreapparater"</string>
    <string name="bluetooth_device_controls_title" msgid="1895676556354697234">"Indstillinger for høreapparat"</string>
    <string name="bluetooth_device_controls_summary" msgid="8115767735418425663">"Genvej, høreapparatskompatibilitet"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"For denne enhed"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Lydudgang"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Om lydudgang"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Få din lyd til at gå gennem dit høreapparat eller din telefonhøjttaler"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Relaterede"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Ringetone og alarmer"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Lyd under opkald"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Medier"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Notifikationer og systemlyde"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Som standard fastlægges lydudgangen af de enkelte apps"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Unavngiven Bluetooth-enhed"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Søger"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Der blev ikke fundet Bluetooth-enheder."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Anmodning om Bluetooth-parring"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Anmodning om parring"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Tryk for at parre med <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth er slået fra"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Tryk for at aktivere"</string>
    <string name="device_picker" msgid="2427027896389445414">"Vælg Bluetooth-enhed"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> ønsker at aktivere Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> ønsker at deaktivere Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"En app ønsker at aktivere Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"En app ønsker at deaktivere Bluetooth."</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Aktiverer Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Bluetooth slukker??"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Anmodning om Bluetooth-forbindelse"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Anmodning om adgang til telefonbog"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Anmodning om adgang til meddelelse"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Vises som \"<xliff:g id="DEVICE_NAME">^1</xliff:g>\" på andre enheder"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Aktivér Bluetooth for at oprette forbindelse til andre enheder."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Dine enheder"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Par en ny enhed"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Deaktiver Bluetooth A2DP-hardwareaflastning"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Deaktiver aflastning af hardware for Bluetooth LE-lyd"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Vil du genstarte enheden?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Genstart enheden for at skifte indstilling"</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Genstart"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Deaktiver"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Deaktiver Bluetooth LE-lyd"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Deaktiverer funktionen Bluetooth LE-lyd, hvis enheden understøtter denne LE-lyd til hardware."</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Vis kontakten til LE-lyd i Enhedsoplysninger"</string>
    <string name="bluetooth_bypass_leaudio_allowlist" msgid="7392319491894565552">"Omgå tilladelsesliste for Bluetooth LE-lyd"</string>
    <string name="bluetooth_bypass_leaudio_allowlist_summary" msgid="8999245286359656738">"Brug LE-lyd som standard, selvom det ikke er verificeret, at den eksterne LE-lydenhed opfylder kriterierne for tilladelseslisten."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Medieenheder"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Opkaldsenheder"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Andre enheder"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Gemte enheder"</string>
    <string name="connected_device_fast_pair_device_title" msgid="543124539265592392">"Knyttet til kontoen"</string>
    <string name="connected_device_previously_associated_fast_pair_device_title" msgid="8353405823992023457">"Tidligere anvendt med kontoen"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth aktiveres for at parre"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Præferencer for forbindelser"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Tidligere forbindelser"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth er aktiveret"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Se alle"</string>
    <string name="connected_device_fast_pair_device_see_all" msgid="4898279230458128620">"Se alt"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Styluspen"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Ved tryk på knappen til styluspennen"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (arbejdsprofil)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Skriv i tekstfelter"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Ignorer alle tryk på styluspen-knappen"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Styluspen"</string>
    <string name="audio_sharing_title" msgid="4144157137502923821">"Deling af lyd"</string>
    <string name="audio_sharing_switch_title" msgid="7052827328670825701">"Del lyd"</string>
    <string name="calls_and_alarms_device_title" msgid="6993559028175454198">"Opkald og alarmer"</string>
    <string name="audio_streams_category_title" msgid="4878022761829895463">"Opret forbindelse til en LE-lydstream"</string>
    <string name="audio_streams_pref_title" msgid="6320485086288646209">"Lydstreams i nærheden"</string>
    <string name="audio_streams_title" msgid="6617990880383079165">"Lydstreams"</string>
    <string name="audio_streams_qr_code_summary" msgid="2838923349871884871">"Opret forbindelse til en lydstream ved hjælp af en QR-kode"</string>
    <string name="audio_streams_empty" msgid="8803517701437394982">"Ingen lydstreams blev fundet i nærheden."</string>
    <string name="date_and_time" msgid="1788358029823431692">"Dato og klokkeslæt"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Ryd"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Proxy-port"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Brug ikke proxy til"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Gendan standarder"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Udfør"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Proxyens hostname"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Bemærk"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Det indtastede hostname er ikke gyldigt."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Den indtastede udeladelsesliste er ikke korrekt formateret. Angiv en kommasepareret liste over udeladte domæner."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Du skal udfylde portfeltet."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Portfeltet skal være tomt, hvis værtsfeltet er tomt."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Den indtastede port er ikke gyldig."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"HTTP-proxyen anvendes af browseren, men må ikke bruges af andre apps."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"Webadresse til PAC: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Ping værtsnavn (www.google.com) IPv4:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"HTTP-klienttest:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Kør ping-test"</string>
    <string name="skip_label" msgid="6380034601349015895">"Spring over"</string>
    <string name="next_label" msgid="1248293387735652187">"Næste"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Sprog"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Rækkefølgen af foretrukne sprog"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Systemsprog"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Fjern"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Tilføj et sprog"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Sprog"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Foretrukket sprog"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Appsprog"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Angiv sprog for hver app"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Appsprog"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Foreslåede sprog"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Alle sprog"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Systemsprog"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Systemstandard"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Sprogvalg for denne app er ikke tilgængeligt i Indstillinger."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Sproget kan adskille sig fra sprogene i appen. Nogle apps understøtter muligvis ikke denne indstilling."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Vælg sprog til hver app"</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Dit system, dine apps og dine websites anvender det første understøttede sprog fra dine foretrukne sprog."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Hvis du vil vælge et sprog for hver app, skal du gå til den pågældende apps sprogindstillinger."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Få flere oplysninger om appsprog"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Vil du ændre systemsproget til %s ?"</string>
    <string name="title_system_locale_addition" msgid="8218683660751479466">"Vil du føje %s til dine foretrukne sprog?"</string>
    <string name="desc_system_locale_addition" msgid="3409917362651596070">"Dette fortæller apps og websites, at du også foretrækker dette sprog."</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Dine enhedsindstillinger og regionsindstillinger ændres."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Rediger"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s er ikke tilgængeligt"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Dette sprog kan ikke bruges som et systemsprog, men du har oplyst apps og websites om, at du foretrækker dette sprog."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Regionsindstillinger"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Angiv præferencer for måleenheder og numre"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Giv apps besked om dine regionsindstillinger, så de kan foretage personlig tilpasning af din brugeroplevelse."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Apps anvender dine regionsindstillinger, når det er muligt."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatur"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Ugens første dag"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Præferencer for tal"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Brug standard"</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">"Søndag"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Mandag"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Tirsdag"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Onsdag"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Torsdag"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Fredag"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Lørdag"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Hvis en app ikke understøtter regionsindstillinger, anvender appen sine lokale standardindstillinger."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Få flere oplysninger om sprogpræferencer."</string>
    <string name="category_title_terms_of_address" msgid="4309422700380895278">"Yderligere præferencer"</string>
    <string name="terms_of_address_title" msgid="4064593634733842458">"Tiltaleform"</string>
    <string name="terms_of_address_summary" msgid="6136134336560679144">"Angiv, hvordan du vil tiltales"</string>
    <string name="terms_of_address_intro_title" msgid="6149691509414243483">"Apps kan bruge din valgte tiltaleform for at tilpasse, hvordan de tiltaler dig."</string>
    <string name="terms_of_address_not_specified" msgid="4439257779351251973">"Ikke angivet"</string>
    <string name="terms_of_address_feminine" msgid="1743479869695539283">"Femininum"</string>
    <string name="terms_of_address_masculine" msgid="983106046135098856">"Maskulinum"</string>
    <string name="terms_of_address_neutral" msgid="5475414185543112478">"Neutral"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Vil du fjerne det valgte sprog?}one{Vil du fjerne det valgte sprog?}other{Vil du fjerne de valgte sprog?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Al tekst vises på et andet sprog."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Du kan ikke fjerne alle sprog."</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Behold mindst ét foretrukket sprog"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Ikke tilgængeligt som systemsprog"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Flyt op"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Flyt ned"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Flyt til toppen"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Flyt til bunden"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Fjern sprog"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Vælg aktivitet"</string>
    <string name="cancel" msgid="5780102414089664898">"Annuller"</string>
    <string name="okay" msgid="4827099303045669054">"OK"</string>
    <string name="forget" msgid="3754013654135912783">"Glem"</string>
    <string name="save" msgid="3125033126936493822">"Gem"</string>
    <string name="done" msgid="7497982645646431310">"Udfør"</string>
    <string name="apply" msgid="7834684883190163536">"Anvend"</string>
    <string name="share" msgid="8502235338607613795">"Del"</string>
    <string name="add" msgid="8335206931421683426">"Tilføj"</string>
    <string name="remove" msgid="1028414219245072102">"Fjern"</string>
    <string name="settings_label" msgid="943294133671632976">"Indstillinger"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Indstillinger"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Genvej til Indstillinger"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Flytilstand"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Trådløs og netværk"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Opret forbindelse til datatjenester ved roaming"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Opret forbindelse til datatjenester ved roaming"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Du skal muligvis betale roaminggebyrer."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Indstil klokkeslættet automatisk"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Indstil automatisk"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Lokationen anvendes til indstilling af tidszonen, når denne kontakt er slået til"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Brug landestandard"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Brug 24-timers format"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Klokkeslæt"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Tidsformat"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Tidszone"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Vælg tidszone"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Dato"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Søg efter region"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Region"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Vælg UTC-forskydning"</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">"Anvender <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> starter <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Bruger <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Ingen sommertid/vintertid."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Sommertid"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Standardtid"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Vælg efter region"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Vælg efter UTC-forskydning"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Lås efter skærmens timeout"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> efter timeout"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Straks efter timeout, medmindre <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> holder den oplåst"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> efter timeout, medmindre <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> holder den oplåst"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Tilføj tekst på låseskærm"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Ingen"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Eksempel: Jacobs Android"</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Lokation"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Brug lokation"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Fra"</string>
    <string name="location_settings_summary_location_on" msgid="4273299717586679786">"{count,plural, =1{Til/# app har adgang til din lokation}one{Til/# app har adgang til din lokation}other{Til/# apps har adgang til din lokation}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Indlæser…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Apps med tilladelse fra enheder i nærheden kan fastslå den relative placering af forbundne enheder."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Adgangen til Lokation er deaktiveret for apps og tjenester. Din enhedslokation kan stadig blive sendt til udrykningsberedskab, hvis du ringer eller sender en sms til et alarmnummer."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="349380666660145540">"Få flere oplysninger om lokationsindstillinger"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Konti"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Sikkerhed"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Kryptering og loginoplysninger"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Låseskærm"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Hvad der skal vises"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Ikke tilgængelig"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Sikkerhedsstatus"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Skærmlås, Find min enhed, appsikkerhed"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Sikkerhed og privatliv"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Appsikkerhed, enhedslås, tilladelser"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Ansigt tilføjet"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Konfiguration er påkrævet"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Ansigtsoplåsning"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Ansigtsoplåsning til arbejdsprofil"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Sådan konfigurerer du ansigtsoplåsning"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Konfigurer ansigtsoplåsning"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Brug dit ansigt til godkendelse"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Start"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Hvis hjælpefunktionen ansigtsoplåsning er deaktiveret, fungerer nogle konfigurationstrin muligvis ikke korrekt via TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Gå tilbage"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Fortsæt konfig."</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Brug avanceret konfiguration"</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">"Annuller"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Nej tak"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Acceptér"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Mere"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Lås op med dit ansigt"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Tillad ansigtsoplåsning"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Brug dit ansigt til godkendelse"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Lås din telefon op eller godkend køb ved hjælp af dit ansigt.\n\nBemærk! Du kan ikke bruge dit ansigt til at låse denne enhed op. Kontakt administratoren for din organisation for at få flere oplysninger."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Brug dit ansigt til at låse din telefon op, godkende køb og logge ind i apps"</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">"Centrer dit ansigt i cirklen"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Spring over"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Du har tilføjet det maksimale antal ansigter"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Der kan ikke tilføjes flere ansigter"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Registreringen kunne ikke gennemføres"</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">"Tidsgrænsen for ansigtsscanning blev overskredet. Prøv igen."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Ansigtsscanningen mislykkedes."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Så er du klar. Godt gået."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Udfør"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Gør ansigtsoplåsningens registrering mere effektiv"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Konfigurer ansigtsoplåsning igen"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Konfigurer ansigtsoplåsning igen"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Gør sikkerheden og registreringen bedre"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Konfigurer ansigtsoplåsning"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Slet din aktuelle ansigtsmodel for at konfigurere ansigtsoplåsning igen.\n\nDin ansigtsmodel slettes permanent og forsvarligt.\n\nEfter sletningen skal du bruge din pinkode, dit mønster eller din adgangskode til at låse telefonen op eller til godkendelse i apps."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Slet din aktuelle ansigtsmodel for at konfigurere ansigtsoplåsning igen.\n\nDin ansigtsmodel slettes permanent og forsvarligt.\n\nEfter sletningen skal du bruge dit fingeraftryk, din pinkode, dit mønster eller din adgangskode til at låse telefonen op eller til godkendelse i apps."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Brug ansigtsoplåsning til"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Når du bruger ansigtsoplåsning"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Kræv, at øjnene skal være åbne"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Dine øjne skal være åbne for at låse telefonen op"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Bed altid om bekræftelse"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Kræv altid et bekræftelsestrin ved brug af ansigtsoplåsning i apps"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Slet ansigtsmodel"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Konfigurer ansigtsoplåsning"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Skal ansigtsmodellen slettes?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Din ansigtsmodel slettes permanent og på sikker vis.\n\nNår den er slettet, skal du bruge din pinkode, dit mønster eller din adgangskode til at låse din telefon op eller til godkendelse i apps."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Din ansigtsmodel slettes permanent og på sikker vis.\n\nNår den er slettet, skal du bruge din pinkode, dit mønster eller din adgangskode til at låse din telefon op."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Din ansigtsmodel slettes permanent og på sikker vis.\n\nNår den er slettet, skal du bruge dit fingeraftryk, din pinkode, dit mønster eller din adgangskode til at låse din telefon op eller til godkendelse i apps."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Din ansigtsmodel slettes permanent og på sikker vis.\n\nNår den er slettet, skal du bruge dit fingeraftryk, din pinkode, dit mønster eller din adgangskode til at låse din telefon op."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Brug ansigtsoplåsning til at låse din telefon op"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Fingeraftryk"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Fingeraftryk"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Når du bruger fingeroplåsning"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Fingeraftryk til arbejdsprofil"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Tilføj fingeraftryk"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Fingeraftryk tilføjet}one{# fingeraftryk tilføjet}other{# fingeraftryk tilføjet}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Konfiguration er påkrævet"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Konfigurer dit fingeraftryk"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Tillad fingeroplåsning"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Brug dit fingeraftryk"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Få flere oplysninger om fingeroplåsning"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Du bestemmer"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Du og dit barn har kontrollen"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Husk!"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Lås din telefon op eller godkend køb ved hjælp af dit fingeraftryk.\n\nBemærk! Du kan ikke bruge dit fingeraftryk til at låse op for denne enhed. Få flere oplysninger ved at kontakte administratoren for din organisation."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Annuller"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Nej tak"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Acceptér"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Spring fingeraftryk over?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Konfigurationen af fingeraftryk tager ikke mere end et minut eller to. Hvis du springer dette trin over, kan du tilføje dit fingeraftryk på et senere tidspunkt i indstillingerne."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Når du ser dette ikon, kan du bruge dit fingeraftryk til godkendelse, f.eks. ved login i apps eller godkendelse af et køb"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Husk!"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Sådan fungerer det"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Fingeroplåsning opretter en unik model af dit fingeraftryk, så din identitet kan verificeres. For at oprette denne fingeraftryksmodel under konfigurationen skal du tage billeder af dit fingeraftryk fra forskellige vinkler."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Fingeroplåsning opretter en unik model af dit barns fingeraftryk, så barnets identitet kan verificeres. For at oprette denne fingeraftryksmodel under konfigurationen skal dit barn tage billeder af sit fingeraftryk fra forskellige vinkler."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Du får de bedste resultater ved at bruge en skærmbeskytter, der er Made For Google-certificeret. Dit fingeraftryk virker muligvis ikke med andre skærmbeskyttere."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Du får de bedste resultater ved at bruge en skærmbeskytter, der er Made For Google-certificeret. Dit barns fingeraftryk virker muligvis ikke med andre skærmbeskyttere."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Uroplåsning"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="5032953826653108646">"Når du konfigurerer ansigts- og fingeroplåsning, beder din telefon om dit fingeraftryk, hvis du er iført en maske eller befinder dig et mørkt sted.\n\nUroplåsning er en nem måde at låse telefonen op, f.eks. når dine hænder er våde eller dit ansigt ikke genkendes."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="5881355884547769337">"Uroplåsning er en nem måde at låse telefonen op, f.eks. når dit fingeraftryk ikke genkendes."</string>
    <string name="biometric_settings_intro_with_face" msgid="7671919122230588521">"Uroplåsning er en nem måde at låse telefonen op, f.eks. når dit ansigt ikke genkendes."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Brug dit fingeraftryk eller ur til at"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Brug dit ansigt eller ur til at"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Brug dit ansigt, fingeraftryk eller ur til at"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Brug dit ur til at"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Brug af ansigt eller ur"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Brug af fingeraftryk eller ur"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Brug af ansigt, fingeraftryk eller ur"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Brug af ur"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Konfigurer ansigtsoplåsning eller fingeroplåsning først"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Du kan låse op med dit ur, når dit ansigt eller fingeraftryk ikke kan genkendes"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Konfigurer først fingeroplåsning"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Du kan låse op med dit ur, når dit fingeraftryk ikke kan genkendes"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Konfigurer først ansigtsoplåsning"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Du kan låse op med dit ur, når dit ansigt ikke kan genkendes"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Konfigurer"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Fingeraftryk <xliff:g id="WATCH">%s</xliff:g> er tilføjet"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Fingeraftryk og <xliff:g id="WATCH">%s</xliff:g> er tilføjet"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Ansigt og <xliff:g id="WATCH">%s</xliff:g> er tilføjet"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Ansigt, fingeraftryk og <xliff:g id="WATCH">%s</xliff:g> er tilføjet"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Ansigt, fingeraftryk og <xliff:g id="WATCH">%s</xliff:g> er tilføjet"</string>
    <string name="security_settings_remoteauth_preference_title" msgid="8319680328086089533">"Oplåsning af Remote Authenticator"</string>
    <string name="security_settings_remoteauth_preference_summary" msgid="1507004469316635196">"Uret er tilføjet"</string>
    <string name="security_settings_remoteauth_enroll_introduction_title" msgid="2151004795778999671">"Konfigurer dit ur"</string>
    <string name="security_settings_remoteauth_enroll_introduction_message" msgid="8737276885766036074">"Uroplåsning er en nem måde at låse telefonen op, f.eks. når dine hænder er våde, eller dit ansigt ikke genkendes.\n\nDu kan bruge dit ur til at låse denne telefon op, når du:"</string>
    <string name="security_settings_remoteauth_enroll_introduction_disagree" msgid="7639258097401796028">"Ikke nu"</string>
    <string name="security_settings_remoteauth_enroll_introduction_agree" msgid="5271119227172049339">"Fortsæt"</string>
    <string name="security_settings_remoteauth_enroll_introduction_more" msgid="1644105894631257595">"Mere"</string>
    <string name="security_settings_remoteauth_enroll_introduction_how_title" msgid="6604152528267830349">"Sådan fungerer det"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_lock_open" msgid="8570511335628725116">"Dit ur skal være oplåst, sidde omkring dit håndled og være tæt på denne telefon. Du behøver ikke at låse dit ur op igen, når det sidder omkring dit håndled."</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_notifications" msgid="4298855831154039694">"Når denne telefon låses op, får du en notifikation på dit ur. Hvis den låses op ved en fejl, kan du trykke på notifikationen for at låse telefonen igen."</string>
    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title" msgid="7974976673323638524">"Du bestemmer"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_remove_watch" msgid="1888318677088986801">"Du kan til enhver tid fjerne dit ur fra uroplåsning i Indstillinger"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_tap_notification" msgid="1597397399097952974">"Tryk på en notifikation"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_swipe_up" msgid="2129230804324634653">"Stryg opad på låseskærmen"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_title" msgid="313016997943607675">"Vælg dit ur"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_list_heading" msgid="8227585438932911013">"Tilgængelige ure"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_disagree" msgid="1670201454188049863">"Annuller"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_agree" msgid="7048336252635730908">"Bekræft"</string>
    <string name="security_settings_remoteauth_enroll_finish_title" msgid="3807372930755413112">"Så er du klar!"</string>
    <string name="security_settings_remoteauth_enroll_finish_description" msgid="4876209907275244653">"Du kan nu bruge dit ur til at låse denne telefon op, når du stryger opad på låseskærmen eller trykker på en notifikation"</string>
    <string name="security_settings_remoteauth_enroll_finish_btn_next" msgid="8072138423143889592">"Udfør"</string>
    <string name="security_settings_remoteauth_settings_title" msgid="1564912618737165129">"Uroplåsning"</string>
    <string name="security_settings_remoteauth_settings_description" msgid="2758239650119457964">"Du kan bruge dit ur til at låse denne telefon op, når du stryger opad på låseskærmen eller trykker på en notifikation"</string>
    <string name="security_settings_remoteauth_settings_info_footer" msgid="795894033901478120">"Hvis du vil bruge uroplåsning, skal uret være oplåst, sidde omkring dit håndled og være tæt på samt forbundet til denne telefon. Hvis forbindelsen afbrydes, skal du låse telefonen op, før du kan bruge uroplåsning.\n\nHusk!\nDu kan kun konfigurere ét ur ad gangen. For at tilføje et nyt ur skal du først fjerne det aktuelle ur."</string>
    <string name="security_settings_remoteauth_settings_learn_more" msgid="5653556124819260050">"Få flere oplysninger om uroplåsning"</string>
    <string name="security_settings_remoteauth_settings_register_new_authenticator" msgid="9191331738306527887">"Tilføj ur"</string>
    <string name="security_settings_remoteauth_settings_remove_device" msgid="2436226120578851282">"Fjern ur"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Fingeraftryk og ansigtsoplåsning"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Ansigtsoplåsning og fingeroplåsning til arbejdsprofil"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Konfiguration er påkrævet"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Ansigt og fingeraftryk er tilføjet"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Ansigt og fingeraftryk er tilføjet"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Når du konfigurerer ansigts- og fingeroplåsning, beder din telefon om dit fingeraftryk, hvis du er iført en maske eller befinder dig et mørkt sted"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Muligheder for oplåsning"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Brug dit ansigt eller fingeraftryk til at"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Låse din telefon op"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Verificere din identitet i apps"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Anvend ansigtsgenkendelse"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Anvend fingeraftryk"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Brug ansigt eller fingeraftryk"</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">"Ansigtsoplåsning kan ikke konfigureres"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Luk den opdelte skærm for at konfigurere ansigtsoplåsning"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Du kan ikke konfigurere fingeraftryk"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Luk opdelt skærm for at konfigurere fingeroplåsning"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"OK"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Vil du springe skærmlås over?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Spring over alligevel"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Gå tilbage"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Spring over"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Annuller"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Tryk på sensoren"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Sæt fingeren på afbryder­knappen uden at trykke"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Sådan konfigurerer du fingeraftryk"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Den sidder på bagsiden af telefonen. Brug pegefingeren."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Fingeraftrykssensoren er på din skærm. Du registrerer dit fingeraftryk på den næste skærm."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Start"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Bevæg fingeren hen over skærmen for at finde sensoren. Hold fingeren på fingeraftrykslæseren."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Illustration med enhed og lokation af fingeraftrykslæser"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Navn"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"OK"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Prøv igen"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Slet"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Tryk på sensoren"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Placer fingeren på sensoren, og løft, når du mærker en vibration"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Tryk fingeren helt ned på sensoren, indtil du mærker en vibration"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Uden at trykke på knappen skal du holde dit fingeraftryk på sensoren, indtil du mærker en vibration.\n\nFlyt din finger en smule, hver gang du mærker en vibration. På den måde registreres en større del af dit fingeraftryk."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Hold fingeren på fingeraftrykssensoren"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Løft, og berør igen"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Én gang til"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Følg fingeraftryksikonet"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Bliv ved med at løfte fingeren for at tilføje forskellige dele af dit fingeraftryk"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Hver gang fingeraftryksikonet flyttes, skal du holde fingeren på det. På den måde registreres en større del af dit fingeraftryk."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Placer din fingerspids på sensoren"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Placer venstre side af fingerspidsen på sensoren"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Placer højre side af fingerspidsen på sensoren"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Placer midten af din fingerspids på sensoren"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Placer din fingerspids på sensoren"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Placer venstre side af din fingerspids på sensoren"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Placer højre side af din fingerspids på sensoren"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Placer siden af din finger på sensoren, og hold den nede. Skift derefter til den anden side."</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"På den måde registreres en større del af dit fingeraftryk"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Scanning af fingeraftryk: <xliff:g id="PERCENTAGE">%d</xliff:g> procent"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"<xliff:g id="PERCENTAGE">%d</xliff:g> procent konfigureret"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Scanning af fingeraftryk: <xliff:g id="PERCENTAGE">%d</xliff:g> procent"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Fingeraftryk tilføjet"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Tryk for at låse op når som helst"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Tryk på sensoren for at låse op, selv når skærmen er slukket. Det øger risikoen for at komme til at låse op ved et uheld."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Skærm, oplåsning"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Gør det senere"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Løft, og berør igen"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Placer siden af din finger på sensoren, og hold den nede. Skift derefter til den anden side."</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Vil du springe registrering af fingeraftryk over?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Du har valgt at bruge fingeraftryk som en metode til at låse din telefon op. Hvis du springer det over nu, skal du konfigurere dette senere. Konfigurationen tager kun omkring et minut."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Vil du springe over konfigurationen af <xliff:g id="OPTIONS">%s</xliff:g>?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Vil du springe pinkodekonfiguration over?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Vil du udelade konfiguration af pinkode og ansigt?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Vil du udelade konfiguration af pinkode og fingeraftryk?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Vil du udelade konfiguration af pinkode, ansigt og fingeraftryk?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Vil du springe adgangskodekonfiguration over?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Vil du udelade konfiguration af adgangskode og ansigt?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Vil du udelade konfiguration af adgangskode og fingeraftryk?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Vil du udelade at bruge adgangskode, ansigt og fingeraftryk?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Vil du springe mønsterkonfiguration over?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Vil du udelade konfiguration af mønster og ansigt?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Vil du udelade konfiguration af mønster og fingeraftryk?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Vil du udelade konfiguration af mønster, ansigt og fingeraftryk?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Konfigurer skærmlås"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Udfør"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Hov! Dette er ikke sensoren"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Tryk på sensoren bagpå med pegefingeren."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Konfigurationen kan ikke gennemføres"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Du kan prøve igen nu eller konfigurere dit fingeraftryk senere i Indstillinger."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Du kan prøve igen nu eller konfigurere dit fingeraftryk senere."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Konfigurationen af fingeraftryk fik timeout"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Du kan konfigurere dit fingeraftryk senere i Indstillinger."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Noget gik galt. Du kan konfigurere dit fingeraftryk senere i Indstillinger."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Du kan konfigurere dit fingeraftryk senere."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Noget gik galt. Du kan konfigurere dit fingeraftryk senere."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Tilføj endnu et"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Næste"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Muligheden for skærmlås er deaktiveret. Kontakt administratoren af din organisation for at få flere oplysninger."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Du kan stadig bruge fingeraftryk til at godkende køb og få adgang til apps."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Løft fingeren, og tryk på sensoren igen"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Fingeraftrykssensoren kan ikke bruges"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Få den repareret."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Flere sikkerhedsindstillinger"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Lås til arbejdsprofil, kryptering og mere"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Kryptering, loginoplysninger og mere"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"sikkerhed, flere sikkerhedsindstillinger, flere indstillinger, avancerede sikkerhedsindstillinger"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Flere privatlivsindstillinger"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Mere sikkerhed og privatliv"</string>
    <string name="security_header" msgid="961514795852103424">"Sikkerhed"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Privatliv"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Arbejdsprofil"</string>
    <string name="private_space_title" msgid="7078627930195569767">"Privat område"</string>
    <string name="private_space_summary" msgid="8237652417163408001">"Skjul apps i en privat mappe"</string>
    <string name="private_space_description" msgid="5494963647270826210">"Skjul apps i en privat mappe, som kun du kan tilgå"</string>
    <string name="private_space_lock_title" msgid="3006539720164938296">"Lås til privat rum"</string>
    <string name="private_space_one_lock_summary" msgid="2759953747682959371">"Du kan låse op for det private område på samme måde, som du låser din enhed op, eller ved at vælge en anden lås"</string>
    <string name="private_space_screen_lock_title" msgid="8679383894967823163">"Brug enhedens skærmlås"</string>
    <string name="private_space_biometric_title" msgid="3934339826674553174">"Ansigtsoplåsning og fingeroplåsning"</string>
    <string name="private_space_biometric_summary" msgid="4403837276018724581">"Tryk for at konfigurere"</string>
    <string name="private_space_screen_lock_summary" msgid="394837965365561070">"Den samme som enhedens skærmlås"</string>
    <string name="private_space_new_lock_title" msgid="7306873010565337671">"Vil du vælge en ny lås til det private område?"</string>
    <string name="private_space_hide_title" msgid="8687034008994037610">"Skjul, når det er låst"</string>
    <string name="privatespace_hide_page_title" msgid="972581369094289386">"Skjul det private område, når det er låst"</string>
    <string name="privatespace_hide_page_summary" msgid="1052569521186403642">"Hvis andre ikke må kende til det private område på din enhed, kan du skjule det på listen over apps"</string>
    <string name="privatespace_access_header" msgid="982809349769470185">"Åbn dit private område, når det er skjult"</string>
    <string name="privatespace_search_description" msgid="983837656432484282">"Søg efter \"privat rum\" i søgefeltet"</string>
    <string name="privatespace_tap_tile_description" msgid="4146608898639668340">"Tryk på handlingsfeltet Privat område"</string>
    <string name="privatespace_unlock_description" msgid="4132755357482447360">"Lås dit private område op"</string>
    <string name="privatespace_hide_off_summary" msgid="7227778747159633671">"Fra"</string>
    <string name="privatespace_hide_on_summary" msgid="6136704537527640183">"Til"</string>
    <string name="private_space_category_system" msgid="1286843321867285700">"System"</string>
    <string name="private_space_delete_title" msgid="3075645119800272800">"Slet det private område"</string>
    <string name="private_space_deleted" msgid="7825768516955610897">"Det private område er slettet"</string>
    <string name="private_space_delete_failed" msgid="8500755484258565011">"Det private område kunne ikke slettes"</string>
    <string name="no_device_lock_title" msgid="1078223464721029954">"Konfigurer en skærmlås"</string>
    <string name="no_device_lock_summary" msgid="7436025227616244687">"Konfigurer en skærmlås på enheden for at bruge dit private område"</string>
    <string name="no_device_lock_action_label" msgid="2640487005629001288">"Konfigurer skærmlås"</string>
    <string name="no_device_lock_cancel" msgid="4412602160321228863">"Annuller"</string>
    <string name="private_space_cancel_label" msgid="379259667396956886">"Annuller"</string>
    <string name="private_space_setup_button_label" msgid="2094882154623560585">"Konfigurer"</string>
    <string name="private_space_setup_title" msgid="7091257695872833671">"Konfigurer et privat område"</string>
    <string name="private_space_hide_apps_summary" msgid="6272406822568588610">"Gem private apps i et separat område, som du kan skjule eller låse"</string>
    <string name="private_space_how_title" msgid="6878224242661347658">"Sådan fungerer det"</string>
    <string name="private_space_access_bottom_text" msgid="8931773427017046981">"Du kan få adgang til dit private område nederst på din liste over apps"</string>
    <string name="private_space_protected_lock_text" msgid="3926344387256377994">"Apps i dit private område er beskyttet af en lås"</string>
    <string name="private_space_hidden_notifications_text" msgid="1487992156742340621">"Notifikationer fra apps i dit private område er skjult, når det er låst"</string>
    <string name="private_space_apps_permission_text" msgid="7030946025253366172">"Apps i dit private område vises ikke i tilladelsesmanager, privatlivspanelet eller andre indstillinger, når det private område er låst.\n\nDu kan ikke flytte dit private område til en ny enhed. Hvis du vil bruge det private område på en anden enhed, skal du konfigurere et nyt privat område.\n\nPersoner, der slutter din enhed til en computer eller installerer skadelige apps på din enhed, kan muligvis få adgang til dit private område."</string>
    <string name="private_space_setting_up_text" msgid="8458035555212009528">"Konfigurerer et privat område…"</string>
    <string name="private_space_notifications_hidden_title" msgid="4377296080723608107">"Notifikationer fra apps i dit private område er skjult, når området er låst"</string>
    <string name="private_space_share_photos_title" msgid="2276051999632122847">"Lås området op for at dele billeder eller filer fra apps, der er gemt i dit private område"</string>
    <string name="private_space_apps_installed_title" msgid="2428207301009983268">"Visse apps er allerede installeret i dit private område"</string>
    <string name="private_space_error_screen_title" msgid="1210906480024148398">"Det private område kunne ikke konfigureres"</string>
    <string name="private_space_tryagain_label" msgid="8305362615231738367">"Prøv igen"</string>
    <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Brug skærmlås til at låse dit private område op?"</string>
    <string name="private_space_lockscreen_summary" msgid="430569465080645805">"Du kan låse dit private område op på samme måde, som du låser din enhed op, eller ved at vælge en anden lås"</string>
    <string name="private_space_use_screenlock_label" msgid="9182153443192032782">"Brug skærmlås"</string>
    <string name="private_space_set_lock_label" msgid="1790408277477408475">"Vælg en ny lås"</string>
    <string name="private_space_success_title" msgid="4351904015352046118">"Det var det hele."</string>
    <string name="private_space_access_text" msgid="4258842502257201013">"Hvis du vil åbne dit private område, skal du gå til din liste over apps og rulle ned"</string>
    <string name="private_space_done_label" msgid="1020482651595246071">"Udfør"</string>
    <string name="private_space_scrolldown_to_access" msgid="4820954877349434545">"Rul ned for at finde det private område"</string>
    <string name="private_space_retry_signin_title" msgid="2340841075193680666">"Log ind for at konfigurere et privat område"</string>
    <string name="private_space_retry_summary" msgid="1976929616948459609">"Du skal logge ind på en konto for at konfigurere et privat rum"</string>
    <string name="private_space_lock_setup_title" msgid="6541564212199510787">"Vælg en lås til dit private område"</string>
    <string name="private_space_lock_setup_description" msgid="423405593476300918">"Du kan låse dit private område op med dit fingeraftryk. Af hensyn til sikkerheden kræver denne mulighed en alternativ lås."</string>
    <string name="privatespace_unhide_header" msgid="1192011539687584004">"Få vist det private område (ikke den endelige brugeroplevelse)"</string>
    <string name="privatespace_open_settings" msgid="5038101805604421393">"Åbn appen Indstillinger"</string>
    <string name="privatespace_tap_settings" msgid="928932826450238276">"Tryk på Sikkerhed og privatliv &gt; Privat område &gt; Skjul det private område, når det er låst"</string>
    <string name="privatespace_turnoff_hide" msgid="4858511423837613842">"Deaktiver kontakten for Skjul det private område, når det er låst"</string>
    <string name="privatespace_development_note" msgid="2999992301558700721">"Bemærkning til Googlere: Denne funktion er stadig under udvikling"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Du kan tilføje op til <xliff:g id="COUNT">%d</xliff:g> fingeraftryk"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Du har tilføjet det maksimale antal fingeraftryk"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Du kan ikke tilføje flere fingeraftryk"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Slet \"<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\""</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Du vil ikke have mulighed for at bruge dit fingeraftryk til at låse din arbejdsprofil op, godkende køb eller logge ind i arbejdsapps."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Kryptering"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Krypteret"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Konfigurer en skærmlås"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Få ekstra beskyttelse ved at konfigurere en pinkode, et mønster eller en adgangskode for denne enhed."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Konfigurer skærmlås"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Konfigurer en skærmlås"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Beskyt denne enhed bedre ved at konfigurere en pinkode, et mønster eller en adgangskode."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Beskyt din telefon"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Tilføj fingeraftryk for at låse op"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Vælg skærmlås"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Vælg en skærmlås"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Vælg en ny skærmlås"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Vælg en lås for apps til arbejdsprofil"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Vælg en ny lås for arbejdsapps"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Konfigurer en alternativ metode til skærmlåsning for at opnå større sikkerhed"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Vælg din alternative metode til skærmlåsning"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Din it-administrator kan ikke nulstille en glemt skærmlås."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Angiv en separat arbejdslås"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Hvis du glemmer denne lås, kan du få din it-administrator til at nulstille den"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Valgmuligheder for skærmlås"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Valgmuligheder for skærmlås"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Bekræft oplåsning automatisk"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Låser automatisk op, hvis du indtaster en korrekt pinkode på 6 eller flere cifre. Dette er lidt mindre sikkert end at trykke på Enter for at bekræfte pinkoden."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Bekræft den korrekte pinkode automatisk"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Det er mere sikkert at bekræfte din pinkode ved at trykke på Enter end at bruge automatisk bekræftelse"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Angiv enhedens pinkode for at aktivere automatisk bekræftelse"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Angiv enhedens pinkode for at deaktivere automatisk bekræftelse"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Skærm­lås"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Lås til arbejdsprofil"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Ingen"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Stryg"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Mønster"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"Pinkode"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Adgangskode"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Ikke nu"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Aktuel skærmlås"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Mønster • Fingeraftryk"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"Pinkode • Fingeraftryk"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Adgangskode • Fingeraftryk"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Fortsæt uden fingeraftryk"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Mønster • Ansigt"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"Pinkode • Ansigt"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Adgangskode • Ansigt"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Fortsæt uden ansigtsoplåsning"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Fortsæt uden fingeraftryk eller ansigtsgenkendelse"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Ingen"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Stryg"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Mønster"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"Pinkode"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Adgangskode"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Vil du slette skærmlåsen?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Vil du fjerne profilbeskyttelsen?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Et mønster beskytter din telefon, hvis den bliver væk eller stjålet"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Et mønster beskytter din telefon, hvis den bliver væk eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette medfører også sletning af den fingeraftryksmodel, der er gemt på din enhed. Du kan ikke længere bruge dit fingeraftryk til godkendelse i apps."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Et mønster beskytter din telefon, hvis den bliver væk eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Din ansigtsmodel bliver også slettet permanent og på sikker vis. Du kan ikke længere bruge dit ansigt til godkendelse i apps."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Et mønster beskytter din telefon, hvis den bliver væk eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette medfører også sletning af den fingeraftryksmodel, der er gemt på din enhed. Din ansigtsmodel bliver også slettet permanent og på sikker vis. Du kan ikke længere bruge dit ansigt eller fingeraftryk til godkendelse i apps."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"En pinkode beskytter din telefon, hvis den bliver væk eller stjålet"</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"En pinkode beskytter din telefon, hvis den bliver væk eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette medfører også sletning af den fingeraftryksmodel, der er gemt på din enhed. Du kan ikke længere bruge dit fingeraftryk til godkendelse i apps."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"En pinkode beskytter din telefon, hvis den bliver væk eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Din ansigtsmodel bliver også slettet permanent og på sikker vis. Du kan ikke længere bruge dit ansigt til godkendelse i apps."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"En pinkode beskytter din telefon, hvis den bliver væk eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette medfører også sletning af den fingeraftryksmodel, der er gemt på din enhed. Din ansigtsmodel bliver også slettet permanent og på sikker vis. Du kan ikke længere bruge dit ansigt eller fingeraftryk til godkendelse i apps."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"En adgangskode beskytter din telefon, hvis den bliver væk eller stjålet"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"En adgangskode beskytter din telefon, hvis den bliver væk eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette medfører også sletning af den fingeraftryksmodel, der er gemt på din enhed. Du kan ikke længere bruge dit fingeraftryk til godkendelse i apps."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"En adgangskode beskytter din telefon, hvis den bliver væk eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Din ansigtsmodel bliver også slettet permanent og på sikker vis. Du kan ikke længere bruge dit ansigt til godkendelse i apps."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"En adgangskode beskytter din telefon, hvis den bliver væk eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette medfører sletning af den fingeraftryksmodel, der er gemt på din enhed. Din ansigtsmodel bliver også slettet permanent og på sikker vis. Du kan ikke længere bruge dit ansigt eller fingeraftryk til godkendelse i apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Funktionerne til enhedsbeskyttelse fungerer ikke uden din skærmlås."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Funktionerne til enhedsbeskyttelse fungerer ikke uden din skærmlås.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette medfører også sletning af den fingeraftryksmodel, der er gemt på din enhed. Du kan ikke længere bruge dit fingeraftryk til godkendelse i apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Funktioner til enhedsbeskyttelse fungerer ikke uden skærmlåsen.<xliff:g id="EMPTY_LINE">

</xliff:g>Din ansigtsmodel bliver også slettet permanent og på sikker vis. Du kan ikke længere bruge dit ansigt til godkendelse i apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Funktionerne til enhedsbeskyttelse fungerer ikke uden din skærmlås.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette medfører sletning af den fingeraftryksmodel, der er gemt på din enhed. Din ansigtsmodel bliver også slettet permanent og på sikker vis. Du kan ikke længere bruge dit ansigt eller fingeraftryk til godkendelse i apps."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Slet"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> anbefaler en stærk pinkode eller adgangskode og fungerer muligvis ikke som forventet uden en af disse"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> anbefaler en ny pinkode eller adgangskode og fungerer muligvis ikke som forventet uden en af disse"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> anbefaler et nyt mønster, en ny pinkode eller en ny adgangskode og fungerer muligvis ikke som forventet uden en af disse"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> anbefaler en ny skærmlås"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Prøv igen. <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g>. forsøg ud af <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Dine data bliver slettet"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Hvis du angiver et forkert mønster i næste forsøg, slettes dataene på denne enhed"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Hvis du angiver en forkert pinkode i næste forsøg, slettes dataene på denne enhed"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Hvis du angiver en forkert adgangskode i næste forsøg, slettes dataene på denne enhed"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Hvis du angiver et forkert mønster i næste forsøg, slettes denne bruger"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Hvis du angiver en forkert pinkode i næste forsøg, slettes denne bruger"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Hvis du angiver en forkert adgangskode i næste forsøg, slettes denne bruger"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Hvis du angiver et forkert mønster i næste forsøg, slettes din arbejdsprofil og de tilhørende data"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Hvis du angiver en forkert pinkode i næste forsøg, slettes din arbejdsprofil og de tilhørende data"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Hvis du angiver en forkert adgangskode i næste forsøg, slettes din arbejdsprofil og de tilhørende data"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Skal indeholde mindst # tegn}one{Skal indeholde mindst # tegn}other{Skal indeholde mindst # tegn}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Hvis du kun bruger tal, skal adgangskoden indeholde mindst 1 ciffer}one{Hvis du kun bruger tal, skal adgangskoden indeholde mindst # ciffer}other{Hvis du kun bruger tal, skal adgangskoden indeholde mindst # cifre}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{Pinkoden skal indeholde mindst # ciffer}one{Pinkoden skal indeholde mindst # ciffer}other{Pinkoden skal indeholde mindst # cifre}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{Pinkoden skal indeholde mindst # ciffer, men en pinkode på {minAutoConfirmLen} cifre anbefales for at øge sikkerheden}one{Pinkoden skal indeholde mindst # ciffer, men en pinkode på {minAutoConfirmLen} cifre anbefales for at øge sikkerheden}other{Pinkoden skal indeholde mindst # cifre, men en pinkode på {minAutoConfirmLen} cifre anbefales for at øge sikkerheden}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Skal indeholde færre end # tegn}one{Skal indeholde færre end # tegn}other{Skal indeholde færre end # tegn}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Skal indeholde færre end # tal}one{Skal indeholde færre end # tal}other{Skal indeholde færre end # tal}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Enhedens administrator tillader ikke brug af en nylig brugt pinkode"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Der kan ikke bruges et ugyldigt tegn"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Skal indeholde mindst 1 bogstav}one{Skal indeholde mindst # bogstav}other{Skal indeholde mindst # bogstaver}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Skal indeholde mindst 1 lille bogstav}one{Skal indeholde mindst # lille bogstav}other{Skal indeholde mindst # små bogstaver}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Skal indeholde mindst 1 stort bogstav}one{Skal indeholde mindst # stort bogstav}other{Skal indeholde mindst # store bogstaver}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Skal indeholde mindst 1 tal}one{Skal indeholde mindst # tal}other{Skal indeholde mindst # tal}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Skal indeholde mindst 1 specialtegn}one{Skal indeholde mindst # specialtegn}other{Skal indeholde mindst # specialtegn}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Skal indeholde mindst 1 tegn, som ikke er et bogstav}one{Skal indeholde mindst # tegn, som ikke er et bogstav}other{Skal indeholde mindst # tegn, som ikke er bogstaver}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Skal indeholde mindst 1 tegn, som ikke er et tal}one{Skal indeholde mindst # tegn, som ikke er et tal}other{Skal indeholde mindst # tegn, som ikke er tal}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Enhedens administrator tillader ikke brug af en nylig brugt adgangskode"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Stigende eller faldende talsekvens og gentagne tal er ikke tilladt"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Bekræft"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Ryd"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Skærmlåsen var allerede blevet ændret. Prøv igen med den nye skærmlås."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Annuller"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Næste"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Apps til enhedsadministration"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Ingen aktive apps"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aktiv app}one{# aktiv app}other{# aktive apps}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Trust agents"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Hvis du vil bruge dette, skal du først konfigurere en skærmlås"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Ingen"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 aktiv trust agent}one{# aktiv 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">"Vil du parre med <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="5310869364570266209">"Føj et nyt medlem til det eksisterende koordinerede sæt"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Bluetooth-parringskode"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Angiv parringskoden, og tryk på Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"Pinkode indeholder bogstaver eller symboler"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Normalt 0000 eller 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Skal bestå af 16 cifre"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Du skal muligvis også indtaste denne pinkode på den anden enhed."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Du skal muligvis også indtaste denne adgangsnøgle på den anden enhed."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Bekræft for at parre med det koordinerede sæt"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Giv adgang til dine kontakter og din opkaldshistorik"</string>
    <string name="bluetooth_pairing_phonebook_toggle_text" msgid="2474015367387690034">"Tillad også adgang til kontakter og opkaldshistorik"</string>
    <string name="bluetooth_pairing_phonebook_toggle_details" msgid="1367197978487212581">"Oplysningerne bruges til opkaldsmeddelelser m.m."</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Der kunne ikke oprettes forbindelse til <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Tilgængelige enheder"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Forbind"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Afbryd"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Par og forbind med denne enhed"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="7326727272747345476">"Når Bluetooth er aktiveret, kan enheden kommunikere med andre Bluetooth-enheder i nærheden"</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Når Bluetooth er aktiveret, kan din enhed kommunikere med andre Bluetooth-enheder i nærheden.\n\nFor at forbedre enhedsoplevelsen kan apps og tjenester stadig til enhver tid søge efter enheder i nærheden, også selvom Bluetooth er deaktiveret. Dette kan f.eks. bruges til at forbedre lokationsbaserede funktioner og tjenester. Du kan ændre dette i indstillingerne for Bluetooth-scanning."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Rediger"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Enhedsoplysninger"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Tastaturindstillinger"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Enhedens Bluetooth-adresse: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Enhedens Bluetooth-adresse:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Vil du glemme denne enhed?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Fjern tilknytning"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Vil du fjerne tilknytningen til appen?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"Appen <xliff:g id="APP_NAME">%1$s</xliff:g> opretter ikke længere forbindelse til <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Eksperimentel. Forbedrer lydkvaliteten."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Glem enhed"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Fjern tilknytning til app"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maksimalt antal tilsluttede Bluetooth-lydenheder"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Vælg det maksimale antal Bluetooth-lydenheder, der kan tilsluttes"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Fejlretningslog for NFC-stakke"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Øg loggingsniveauet for NFC-stakke"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Detaljeret NFC-leverandørlog over fejlretninger"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Medtag yderligere enhedsspecifikke leverandørlogs i fejlrapporter, som muligvis indeholder private oplysninger."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Ufiltreret log over NFC NCI"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Registrer detaljerede NFC-pakker, som muligvis indeholder private oplysninger."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Vil du genstarte enheden?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Detaljeret NFC-logging er kun beregnet til udvikling. Yderligere NFC-data inkluderes i fejlrapporter, som muligvis indeholder private oplysninger. Genstart enheden for at ændre denne indstilling."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Genstart"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Cast"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"spejl"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Aktivér trådløs skærm"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Der blev ikke fundet enheder i nærheden."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Tilslutter"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Forbundet"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"I brug"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Ikke tilgængelig"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Indstillinger for trådløs skærm"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Glem"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Udfør"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Navn"</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">"Log ind"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Åbn website"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"<xliff:g id="REMAINING_TIME">%1$s</xliff:g> tilbage"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Udløber <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbps"</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> ønsker at aktivere Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> ønsker at deaktivere Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Verificer bytekoden for apps, der kan fejlrettes"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Tillad, at ART verificerer bytekoden for apps, der kan fejlrettes"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Vis opdateringshastighed"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Vis skærmens aktuelle opdateringshastighed"</string>
    <string name="show_hdr_sdr_ratio" msgid="4188007289024955585">"Vis HDR-/SDR-forhold"</string>
    <string name="show_hdr_sdr_ratio_summary" msgid="986292785096013733">"Vis det aktuelle HDR-/SDR-forhold"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Kræv, at enheden låses op til NFC"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Klar til at overføre appindhold via NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Fra"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Ikke tilgængelig, fordi NFC er slået fra"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Når denne funktion er slået til, kan du overføre appindhold til en anden NFC-kompatibel enhed ved at placere enhederne tæt på hinanden. Du kan f.eks. overføre websider, YouTube-videoer, kontakter og meget mere.\n\nDu skal blot placere enhederne tæt på hinanden (normalt bagside mod bagside) og derefter trykke på din skærm. Appen bestemmer, hvad der overføres."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi-Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Brug Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Indstillinger for Wi-Fi"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Vælg Wi-Fi-netværk"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Aktiverer Wi-Fi..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Deaktiverer Wi-Fi..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Fejl"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"5 GHz-bånd er ikke tilgængeligt i dette land"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"I flytilstand"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Underret om offentlige netværk"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Giv besked, hvis et offentligt netværk af høj kvalitet er tilgængeligt"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Aktivér Wi-Fi automatisk"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Wi-Fi aktiveres igen, når du er i nærheden af gemte netværk af høj kvalitet, f.eks dit hjemmenetværk"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Ikke tilgængelig, fordi lokation er deaktiveret. Aktivér "<annotation id="link">"lokation"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Installer certifikater"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"For at forbedre lokationsnøjagtigheden kan apps og tjenester stadig til enhver tid søge efter Wi‑Fi-netværk, også selvom Wi-Fi er deaktiveret. Dette kan f.eks. bruges til at forbedre lokationsbaserede funktioner og tjenester. Du kan ændre dette i <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>indstillingerne for Wi-Fi-scanning<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Du kan gøre forbedre lokationsnøjagtigheden ved at aktivere Wi-Fi-scanning i <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>indstillingerne for Wi‑Fi-scanning<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Skift automatisk til mobildata"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Brug mobildata, når du ikke har internetadgang via Wi-Fi. Du skal muligvis betale for dataforbrug."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Tilføj netværk"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Wi‑Fi-præferencer"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi-Fi aktiveres igen automatisk"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wi-Fi aktiveres ikke igen automatisk"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi-Fi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Se tilgængelige netværk ved at aktivere Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Søger efter netværk…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Du har ikke tilladelse til at ændre Wi-Fi-netværket."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Vil du slå Wi-Fi-scanning til?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Hvis du vil aktivere Wi-Fi automatisk, skal du først slå Wi-Fi-scanning til."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Wi-Fi-scanning tillader, at apps og tjenester til enhver tid kan søge efter Wi-Fi-netværk, også selvom Wi-Fi er deaktiveret. Dette kan f.eks. bruges til at forbedre lokationsbaserede funktioner og tjenester."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Aktivér"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Wi‑Fi-scanning er slået til"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Avancerede valgmuligheder"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Rulleliste med avancerede valgmuligheder"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"udvid"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Netværksnavn"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Angiv SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Sikkerhed"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Skjult netværk"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Hvis din router ikke udsender et netværks-id, men du gerne vil oprette forbindelse til netværket i fremtiden, kan du indstille det til at være skjult.\n\nDette kan medføre en sikkerhedsrisiko, da din telefon med jævne mellemrum udsender et signal for at finde netværket.\n\nDine routerindstillinger ændres ikke, når du skjuler netværket."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Signalstyrke"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Status"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Overførselshastighed"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Modtagelseshastighed"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Linkhastighed"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frekvens"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"IP-adresse"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Gemt via"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Loginoplysninger til <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"EAP-metode"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Fase 2-godkendelse"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"CA-certifikat"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Minimumversion af TLS"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Certifikatstatus online"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domæne"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Brugercertifikat"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identitet"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonym identitet"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Adgangskode"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Vis adgangskode"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"2,4 GHz-bånd"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"5,0 GHz-bånd foretrækkes"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"IP-indstillinger"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privatliv"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Abonnement"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Se eller skift abonnement"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Tilfældig MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Tilføj en enhed"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Centrer QR-koden nedenfor for at føje enheden til \"<xliff:g id="SSID">%1$s</xliff:g>\""</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Scan QR-kode"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Centrer QR-koden nedenfor for at oprette forbindelse til \"<xliff:g id="SSID">%1$s</xliff:g>\""</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Opret forbindelse til Wi-Fi-netværket ved at scanne en QR-kode"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Del Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Scan denne QR-kode med en anden enhed for at oprette forbindelse til \"<xliff:g id="SSID">%1$s</xliff:g>\""</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Scan denne QR-kode for at oprette forbindelse til \"<xliff:g id="SSID">%1$s</xliff:g>\""</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Prøv igen. Hvis problemet fortsætter, skal du kontakte enhedsproducenten"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Noget gik galt"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Sørg for, at enheden er tilsluttet, opladet og tændt"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Sørg for, at enheden er tilsluttet, opladet og tændt. Hvis problemet fortsætter, skal du kontakte enhedsproducenten"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Tilføjelse af “<xliff:g id="SSID">%1$s</xliff:g>\" understøttes ikke på denne enhed"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Prøv at rykke enheden tættere på dit Wi-Fi-adgangspunkt/din router"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Tjek adgangskoden, og prøv igen"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Kontakt producenten af enheden"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Tjek forbindelsen, og prøv igen"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Vælg netværk"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Vælg et netværk for at oprette forbindelse til din enhed"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Vil du føje denne enhed til \"<xliff:g id="SSID">%1$s</xliff:g>\"?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi blev delt med enheden"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Tilføj en anden enhed"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Vælg et andet netværk"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Enheden kunne ikke tilføjes"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Der blev fundet en enhed"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Deler Wi-Fi med denne enhed…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Opretter forbindelse…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Del hotspot"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="5246641326066972419">"Bekræft, at det er dig"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Adgangskode til Wi-Fi-netværk: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Adgangskode til hotspot: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Opret automatisk forbindelse"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Tillad forbindelse til dette netværk, når det er inden for rækkevidde"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Tilføj enhed"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Brug en QR-kode til at føje en enhed til dette netværk"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR-koden har ikke et gyldigt format"</string>
    <string name="retry" msgid="7542103800274026915">"Prøv igen"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Del med andre enhedsbrugere"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(uændret)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Vælg"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Flere certifikater er tilføjet)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Brug systemets certifikater"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Angiv ikke"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Udvis tillid ved første anvendelse"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Netværksnavnet er for langt."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Domæne skal angives."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Certifikat er påkrævet."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"For bl.a. at forbedre lokationsnøjagtigheden vil <xliff:g id="APP_NAME">%1$s</xliff:g> gerne aktivere netværkssøgning, selv når Wi-Fi er deaktiveret.\n\nVil du tillade dette for alle apps, der gerne vil søge?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"For bl.a. at forbedre lokationsnøjagtigheden vil en ukendt app gerne aktivere netværkssøgning, selv når Wi-Fi er deaktiveret.\n\nVil du tillade dette for alle apps, der gerne vil søge?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Tillad"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Afvis"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Dette netværk har ingen internetadgang. Vil du bruge netværket alligevel?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Nogle apps og tjenester fungerer muligvis ikke pga. begrænset forbindelse. Skal de bruges alligevel?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Spørg ikke igen for dette netværk"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Der er ikke internetadgang via Wi-Fi"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Du kan skifte til mobilnetværket, hvis Wi-Fi-forbindelsen er dårlig. Du kan blive opkrævet betaling for dataforbruget."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Skift til mobilnetværk"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Bliv på Wi-Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Vis aldrig igen"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Forbind"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Forbundet til <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Tilslutter…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Der kunne ikke oprettes forbindelse til netværket"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Netværket er ikke inden for rækkevidde"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Glem"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Rediger"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Gem"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Netværk kunne ikke gemmes"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Annuller"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Vil du glemme netværket?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 netværk}one{# netværk}other{# netværk}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 abonnement}one{# abonnement}other{# abonnementer}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 netværk og abonnement}one{# netværk og abonnement}other{# netværk og abonnementer}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Enhedens MAC-adresse"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Tilfældig MAC-adresse"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Tilfældig MAC-adresse (sidst anvendt)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Netværksoplysninger"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Undernetmaske"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Type"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"IPv6-adresser"</string>
    <string name="hotspot_device_details_category" msgid="3110651914598697220">"Oplysninger om hotspot-enhed"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Internetkilde"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"Wi-Fi"</string>
    <string name="internet_source_mobile_data" msgid="877403889449201789">"Mobildata"</string>
    <string name="internet_source_ethernet" msgid="8338472576454100966">"Ethernet"</string>
    <string name="hotspot_battery_charging_summary" msgid="6690892148553288457">"<xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> – oplades"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Hotspot-forbindelse"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Signalstyrke"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Gemte netværk"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Abonnementer"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Andre netværk"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Angiv en gyldig IP-adresse."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Angiv en gyldig gatewayadresse."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Angiv en gyldig DNS-adresse."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Angiv gyldigt netværkspræfiks på 0-32 tegn."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (undtagen ved tilsidesættelse med privat DNS)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (undtagen ved tilsidesættelse med privat DNS)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Gateway"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Længde på netværkspræfiks"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Søg efter enheder"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Søger…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Omdøb enhed"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Peer-enheder"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Gemte grupper"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Der kunne ikke oprettes forbindelse."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Enheden kunne ikke omdøbes."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Vil du afbryde forbindelsen?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Hvis du afbryder, stoppes forbindelsen til <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Hvis du afbryder, stoppes forbindelsen til <xliff:g id="PEER_NAME">%1$s</xliff:g> og <xliff:g id="PEER_COUNT">%2$s</xliff:g> andre enheder."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Vil du annullere invitationen?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Vil du annullere invitationen til at oprette forbindelse med <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Vil du glemme denne gruppe?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Wi-Fi-hotspot"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Deler ikke internet eller indhold med andre enheder"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Der er ikke indstillet nogen adgangskode"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Navn på hotspot"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Adgangskode til hotspot"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Deaktiver hotspot automatisk"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Når der ikke er forbundet nogen enheder"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Udvid kompatibilitet"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Hjælp andre enheder med at finde dette hotspot. Sænker hotspottets forbindelseshastighed."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Hjælp andre enheder med at finde dette hotspot. Medfører højere batteriforbrug."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Hastighed og kompatibilitet"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2,4 GHz/Kompatibel med de fleste enheder"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz/Kompatibel med mange enheder"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz/Kompatibel med få enheder"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2,4 og 5 GHz/Kompatibel med de fleste enheder"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Vælg en frekvens til dit hotspot. Frekvensen påvirker forbindelsens hastighed, og hvilke typer enheder der kan finde dit hotspot."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Foretrukken frekvens"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Langsommere hastigheder. Kompatibel med de fleste enheder."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Hurtige hastigheder. Kompatibel med mange enheder."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 og 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Hurtige hastigheder. Dette dual-band-hotspot er kompatibelt med de fleste enheder."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Hurtigste hastigheder. Kompatibel med få enheder."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Ikke tilgængelig i dit land eller din region"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Hvis din foretrukne frekvens ikke er tilgængelig, anvender dit hotspot muligvis en anden. Sikkerhedsindstillingerne for hotspottet kan ændres, hvis du justerer frekvensen."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Ikke tilgængeligt med 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Sikkerhedsindstillingerne kan ændres, hvis du justerer frekvensen for hotspottet"</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"Automatisk hotspot"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"Til"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Fra"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Aktiverer hotspot..."</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Deaktiverer hotspot..."</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Netdeling er ikke tilgængeligt"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Kontakt dit mobilselskab for at få flere oplysninger"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> er aktivt"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Vil du gemme dette netværk?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Gemmer…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Gemt"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Der kan ikke gemmes. Prøv igen."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Vil du gemme netværkene?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Gemmer <xliff:g id="NUMBER">%d</xliff:g> netværk…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Netværkene blev gemt"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Opkald via Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Udvid opkaldsdækningen med Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Aktivér Wi-Fi-opkald for at udvide dækningen"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Opkaldspræference"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Opkaldspræference"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Præferencer for roaming"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Præferencer for roaming"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Mobil"</item>
    <item msgid="3027927219952052398">"Kun Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi-Fi"</item>
    <item msgid="7566603075659706590">"Mobil"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Brug mobilnetværk, hvis der ikk er nogen Wi-Fi-forbindelse"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Brug Wi-Fi, hvis mobilnetværket ikke er tilgængeligt"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Ring via Wi‑Fi. Opkaldet afsluttes, hvis Wi-Fi-forbindelsen afbrydes."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Når Wi-Fi-opkald er slået til, kan enheden dirigere opkald via Wi-Fi-netværk eller dit mobilselskabs netværk, afhængigt af hvad du foretrækker, og hvor signalet er stærkest. Før du slår denne funktion til, skal du kontakte dit mobilselskab angående gebyrer og andre oplysninger.<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">"Adresse til nødstilfælde"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Anvendes som din lokation, hvis du foretager et nødopkald via Wi-Fi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Få flere oplysninger"</annotation>" om private DNS-funktioner"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Til"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktivér Wi-Fi-opkald"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Aktivér Wi-Fi-opkald"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Forbindelsen til <xliff:g id="SSID">%1$s</xliff:g> er afbrudt"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Lyd og vibration"</string>
    <string name="account_settings" msgid="255404935489127404">"Konti"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Arbejdsprofilkonti – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Personlig profilkonti"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Konti med klonet profil"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Arbejdskonto – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Personlig konto – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Søg"</string>
    <string name="display_settings" msgid="7197750639709493852">"Skærm"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Roter skærm automatisk"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Fra"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Til"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Til – ansigtsbaseret"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Ansigtsgenkendelse"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Få flere oplysninger om automatisk rotering"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Skærmopløsning"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Høj opløsning"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Fuld opløsning"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Fuld opløsning bruger mere batteri. Nogle apps genstarter muligvis, hvis du skifter opløsning."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Valgt"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Farver"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Naturlige"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Forstærkede"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Mættet"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Selvjusterende"</string>
    <string name="brightness" msgid="6216871641021779698">"Lysstyrke"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Automatisk lysstyrke"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Skærmens lysstyrke tilpasses automatisk på baggrund af dine omgivelser og dine aktiviteter. Du kan flytte skyderen manuelt for at hjælpe Automatisk lysstyrke med at lære dine præferencer."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Til"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Fra"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Skærmens hvidbalance"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="fold_lock_behavior_title" msgid="786228803694268449">"Fortsæt med at bruge apps på Fold"</string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="3212309985294885790">"Øger automatisk opdateringshastigheden op til <xliff:g id="ID_1">%1$d</xliff:g> Hz for noget indhold. Medfører højere batteriforbrug."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Gennemtving højeste opdateringshastighed"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Den højeste opdateringshastighed, som giver forbedret animationskvalitet og reaktionsevne ved berøring. Medfører højere batteriforbrug."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Opmærksom skærm"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Adgang til kameraet kræves"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Der kræves adgangstilladelse til kameraet i forbindelse med opmærksom skærm. Tryk for at administrere tilladelser for Personlig tilpasning på enheden"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Administrer tilladelser"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Holder din skærm tændt, så længe du kigger på den"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Den opmærksomme skærm bruger frontkameraet til at tjekke, om der er nogen, der kigger på skærmen. Funktionen fungerer kun lokalt på enheden, og den gemmer ikke billeder eller sender billeder til Google."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Aktivér opmærksom skærm"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Hold skærmen tændt, så længe du kigger på den"</string>
    <string name="power_consumption_footer_summary" msgid="4901490700555257237">"Længerevarende timeout for skærm bruger mere batteri."</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Kameraet er låst"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Kameraet skal låses op, før du kan bruge ansigtsgenkendelse"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Kameraet skal låses op, før du kan bruge opmærksom skærm"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Ansigtsgenkendelse kræver adgang til kameraet. Tryk for at administrere tilladelser for Personlig tilpasning på enheden"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Administrer tilladelser"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Nattelys"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Nattelys gør farverne på din skærm mere gullige. Det gør din skærm mere behagelig at se på i svag belysning og kan gøre det nemmere at falde i søvn."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Tidsplan"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Ingen"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Aktiveres på valgt tidspunkt"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Aktiveres fra solnedgang til solopgang"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Starttidspunkt"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Sluttidspunkt"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensitet"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Aktiveres aldrig automatisk"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Aktiveres automatisk kl. <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Aktiveres automatisk ved solnedgang"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Deaktiveres aldrig automatisk"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Deaktiveres automatisk kl. <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Deaktiveres automatisk ved solopgang"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Nattelys er deaktiveret"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Enhedslokation er påkrævet til bestemmelse af tidspunkter for solnedgang og solopgang."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Lokationsindstillinger"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Aktivér nu"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Deaktiver nu"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Aktivér indtil solopgang"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Deaktiver indtil solnedgang"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Mørk tilstand"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Tidsplan"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Ingen"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Aktiveres fra solnedgang til solopgang"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Aktiveres på valgt tidspunkt"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Aktiveres ved sengetid"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Status"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Aktiveres aldrig automatisk"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Aktiveres automatisk ved solnedgang"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Aktiveres automatisk kl. <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Aktiveres automatisk ved sengetid"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Deaktiveres aldrig automatisk"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Deaktiveres automatisk ved solopgang"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Deaktiveres automatisk kl. <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Deaktiveres automatisk efter sengetid"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Mørkt tema bruger en sort baggrund på nogle skærme for at spare på batteriet. Tidsplaner for Mørkt tema aktiveres først, når din skærm er slukket."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Mørkt tema følger i øjeblikket din tidsplan for sengetid"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Indstillinger for sengetid"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Timeout for skærmen"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Efter <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> med inaktivitet"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Ikke angivet"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Baggrund"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Baggrund og stil"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Startskærm, låseskærm"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Skift baggrund"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Tilpas din skærm"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Vælg baggrund fra"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Tilpas din telefon"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Prøv forskellige layout, baggrunde og meget mere"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Pauseskærm"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"pauseskærm"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Ikke tilgængelig, da sengetidstilstand er aktiv"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Brug pauseskærm"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Under opladning, eller når enheden er sluttet til en dockingstation"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Når den oplader i dockingstationen"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Under opladning"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Når enheden er tilsluttet en dockingstation"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Aldrig"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Til – <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Fra"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Starttidspunkt"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Løft enheden for at vække den"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Aktiv låseskærm"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Hvornår skal det vises"</string>
    <string name="doze_title" msgid="1523090408230862316">"Væk skærmen ved notifikationer"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Når skærmen er mørk, aktiveres den ved modtagelse af nye notifikationer"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Vis altid tidspunkt og info"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Øget batteriforbrug"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Fed tekst"</string>
    <string name="title_font_size" msgid="570613010306330622">"Skriftstørrelse"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Gør tekst større eller mindre"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Indstillinger for SIM-lås"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"SIM-lås"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Lås SIM-kort"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Skift pinkode til SIM-kort"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"Pinkode til SIM-kort"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Lås SIM-kort"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Lås SIM-kort op"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Nuværende pinkode til SIM-kort"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Ny pinkode til SIM-kort"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Angiv ny pinkode igen"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"Pinkode til SIM-kort"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Angiv en pinkode på mellem 4 og 8 tal"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Pinkoderne er ikke ens"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"PIN-koden til SIM-kortet er ændret"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Pinkoden kan ikke deaktiveres."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Pinkoden kan ikke aktiveres."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"OK"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Annuller"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Vil du bruge <xliff:g id="CARRIER">%1$s</xliff:g> til mobildata?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Du bruger <xliff:g id="CARRIER2_0">%2$s</xliff:g> til mobildata. Hvis du skifter til <xliff:g id="CARRIER1">%1$s</xliff:g>, anvendes <xliff:g id="CARRIER2_1">%2$s</xliff:g> ikke længere til mobildata."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Brug <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Vil du opdatere dit foretrukne SIM-kort?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> er det eneste SIM-kort i din enhed. Vil du bruge dette SIM-kort til mobildata, opkald og sms-beskeder?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Skal dækningen af mobildata forbedres?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Tillad, at din enhed automatisk skifter til <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> ved brug af mobildata, når dækningen er bedre."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Opkald, beskeder og netværkstrafik kan muligvis ses af din organisation."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Forkert pinkode til SIM-kort. Du skal nu kontakte dit mobilselskab for at låse din enhed op."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Du har angivet en forkert pinkode til SIM-kortet. Du har # forsøg tilbage, før du skal kontakte dit mobilselskab for at få låst din enhed op.}one{Du har angivet en forkert pinkode til SIM-kortet. Du har # forsøg tilbage.}other{Du har angivet en forkert pinkode til SIM-kortet. Du har # forsøg tilbage.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Du har angivet en forkert pinkode til SIM-kortet. Du har 1 forsøg tilbage, før du skal kontakte dit mobilselskab for at få låst din enhed op."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Pinkoden til SIM-kortet blev afvist."</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Systemopdateringer"</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">"Sikkerhedsopdatering til Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Hardwareversion"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Produktionsår"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"Udstyrs-id"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Basebandversion"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Kernesystem"</string>
    <string name="build_number" msgid="9009733242117579826">"Buildnummer"</string>
    <string name="module_version" msgid="1787518340082046658">"System­opdatering til Google Play"</string>
    <string name="battery_info" msgid="7873528123969546728">"Batterioplysninger"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Ikke tilgængelig"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Lagerplads"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Lagerplads og cache"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Indstillinger for lagerplads"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (SIM-kortrille <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI-nummer (SIM-kortrille <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI-nummer (SIM-kortrille <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g> – primær)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Vælg et gemt netværk for at se"</string>
    <string name="status_imei" msgid="5719752369250485007">"IMEI-nummer"</string>
    <string name="status_imei_sv" msgid="6908985558726440951">"IMEI SV"</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-nummer (SIM-kortrille <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID-nummer (SIM-kortrille <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g> – primær)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Til"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Fra"</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">"Netværkstype for mobildata"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Netværkstype for mobiltale"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Oplysninger om udbyder"</string>
    <string name="status_data_state" msgid="525196229491743487">"Status for mobildata"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Tjenestetilstand"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Signalstyrke"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Netværk"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"MAC-adresse for Wi-Fi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Enhedens MAC-adresse for Wi-Fi"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Bluetooth-adresse"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Serienummer"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Oppetid"</string>
    <string name="battery_manufacture_date" msgid="7139426520156833987">"Produktionsdato"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Dato for ibrugtagning"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Antal cyklusser"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Ikke tilgængelig"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Beregner..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Omdøb"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Monter"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Skub ud"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formatér SD-kort til flytbar lagerplads"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formatér kort"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formatér som ekstern"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formatér"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Flyt data"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Glem"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Konfigurer"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Frigør plads"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Administrer lagerplads"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Frigør plads"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Gå til appen Filer for at administrere og frigøre plads"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Andre brugere"</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> blev monteret"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"<xliff:g id="NAME">%1$s</xliff:g> kunne ikke monteres"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> blev skubbet sikkert ud"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"<xliff:g id="NAME">%1$s</xliff:g> kunne ikke skubbes sikkert ud"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Omdøb lagerplads"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Dette <xliff:g id="NAME_0">^1</xliff:g> er beskadiget. \n\nFør du kan bruge dette <xliff:g id="NAME_1">^1</xliff:g>, skal det konfigureres."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Du kan formatere dette SD-kort, så du kan gemme billeder, videoer, musik m.m. på det og tilgå dette indhold på andre enheder. \n\n"<b>"Alle data på dette SD-kort ryddes."</b>" \n\n"<b>"Inden du formaterer"</b>" \n\n"<b>"Sikkerhedskopiér billeder og andre medier"</b>" \nFlyt dine mediefiler til en alternativ lagerplads på denne enhed, eller overfør dem til en computer ved hjælp af et USB-kabel. \n\n"<b>"Sikkerhedskopiér apps"</b>" \nAlle apps, der er gemt på dette <xliff:g id="NAME">^1</xliff:g>, afinstalleres, og dataene i dem ryddes. Hvis du vil beholde disse apps, skal du flytte dem til en alternativ lagerplads på denne enhed."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Når du skubber dette <xliff:g id="NAME_0">^1</xliff:g> ud, holder de apps, der er gemt her, op med at fungere, og mediefiler, der er gemt her, er utilgængelige, indtil det er sat i igen."</b>\n\n"Dette <xliff:g id="NAME_1">^1</xliff:g> er formateret til kun at fungere på denne enhed og ikke på nogen andre."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Hvis du vil bruge de apps, billeder eller data, der findes på dette <xliff:g id="NAME">^1</xliff:g>, skal du indsætte det igen. \n\nDu kan også vælge at glemme dette lager, hvis enheden ikke er tilgængelig. \n\nHvis du vælger at glemme, mister du alle data på enheden permanent. \n\nDu kan geninstallere dine apps senere, men de data, de indeholder, og som er gemt på denne enhed, vil gå tabt."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Vil du glemme <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Du mister alle apps, billeder og data, der er gemt på dette <xliff:g id="NAME">^1</xliff:g>."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"System omfatter filer, der anvendes til at køre Android <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Brugere i gæstetilstand kan ikke formatere SD-kort"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formaterer <xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Undlad at fjerne dit <xliff:g id="NAME">^1</xliff:g> under formateringen."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"<xliff:g id="NAME">^1</xliff:g> er formateret"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Flyt <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Flytningen af <xliff:g id="APP">^1</xliff:g> og de tilhørende data til <xliff:g id="NAME_0">^2</xliff:g> tager kun et øjeblik. Du kan ikke bruge appen, før flytningen er gennemført. \n\nFjern ikke dit <xliff:g id="NAME_1">^2</xliff:g> under flytningen."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Du skal låse op for brugeren <xliff:g id="APP">^1</xliff:g>, før du kan flytte data."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Flytter <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Fjern ikke dit <xliff:g id="NAME">^1</xliff:g> under flytningen. \n\nAppen <xliff:g id="APP">^2</xliff:g> på denne enhed vil ikke være tilgængelig, før flytningen er gennemført."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Hvordan vil du bruge dette <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Eller"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Formatér SD-kort til flytbar lagerplads"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Gem billeder, videoer, musik m.m., og få adgang til indholdet fra andre enheder. &lt;a href=https://support.google.com/android/answer/12153449&gt;Se, hvordan du konfigurerer et SD-kort&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formatér"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Konfigurer senere"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Vil du formatere dette <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Dette <xliff:g id="NAME_0">^1</xliff:g> skal formateres, før du kan gemme apps, filer og medier. \n\nFormateringen sletter eksisterende indhold på <xliff:g id="NAME_1">^2</xliff:g>. Sikkerhedskopiér til et andet <xliff:g id="NAME_2">^3</xliff:g> eller en anden enhed, så du undgår at miste indhold."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Dette <xliff:g id="NAME_0">^1</xliff:g> skal formateres, før du kan gemme billeder, videoer, musik m.m. på det. \n\nNår du formaterer, ryddes alt eksisterende indhold på dette <xliff:g id="NAME_1">^2</xliff:g>. Du kan undgå at miste indhold ved at sikkerhedskopiere det til et andet <xliff:g id="NAME_2">^3</xliff:g> eller en anden enhed."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formatér <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Vil du flytte indholdet til <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Under flytningen:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Undlad at fjerne <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Nogle apps vil ikke fungere"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Flyt indhold"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Flyt indhold senere"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Flytter indhold…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Langsomt <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Du kan stadig bruge dette <xliff:g id="NAME_0">^1</xliff:g>, men det er muligvis langsomt. \n\nApps, der er gemt på dette <xliff:g id="NAME_1">^2</xliff:g> fungerer muligvis ikke korrekt, og overførsel af indhold kan tage lang tid. \n\nPrøv at bruge et hurtigere <xliff:g id="NAME_2">^3</xliff:g>, eller brug dette <xliff:g id="NAME_3">^4</xliff:g> som ekstern lagerplads i stedet."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Start forfra"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Fortsæt"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Du kan nu bruge dit <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Du kan nu bruge dit <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Du kan nu bruge dit <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Batteristatus"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Batteriniveau"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Fælles"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Fælles indstillinger"</string>
    <string name="apn_settings" msgid="4295467389400441299">"Adgangspunkter"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Rediger adgangspunkt"</string>
    <string name="apn_add" msgid="9069613192201630934">"Tilføj adgangspunkt"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Ikke angivet"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Ikke angivet"</string>
    <string name="apn_name" msgid="6677695784108157953">"Navn"</string>
    <string name="apn_apn" msgid="5812828833797458602">"Adgangspunkt"</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">"Brugernavn"</string>
    <string name="apn_password" msgid="7435086635953953029">"Adgangskode"</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">"Godkendelsestype"</string>
    <string name="apn_type" msgid="1835573305077788773">"Adgangspunktets type"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Adgangspunktets protokol"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Adgangspunktets roamingprotokol"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Aktivér/deaktiver adgangspunkt"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"Adgangspunktet er aktiveret"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"Adgangspunktet er deaktiveret"</string>
    <string name="bearer" msgid="3231443241639159358">"Bærer"</string>
    <string name="network_type" msgid="748590707422733595">"Netværkstype"</string>
    <string name="network_type_unspecified" msgid="7756349656194518725">"Ikke angivet"</string>
    <string name="mvno_type" msgid="4734654257494971247">"MVNO-type"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"MVNO-værdi"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Slet adgangspunkt"</string>
    <string name="menu_new" msgid="6571230342655509006">"Nyt adgangspunkt"</string>
    <string name="menu_save" msgid="6611465355127483100">"Gem"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Luk"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Feltet Navn skal udfyldes."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"Du skal angive et adgangspunkt."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"MCC-feltet skal indeholde 3 tal."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"MNC-feltet skal indeholde 2 eller 3 tal."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Mobilselskabet tillader ikke, at du tilføjer adgangspunkter af typen %s."</string>
    <string name="error_mmsc_valid" msgid="8380951905485647380">"MMSC-feltet skal være gyldigt."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Gendannelse af standardindstillingerne for adgangspunktet."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Nulstil til standard"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Standardindstillingerne for adgangspunktet er nulstillet."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Nulstil valg"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Nulstil indstillinger for mobilnetværk"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Denne handling nulstiller alle indstillingerne for mobilnetværk"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Vil du nulstille indstillingerne for mobilnetværk?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Nulstil Bluetooth og Wi‑Fi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Denne handling nulstiller alle indstillinger for Wi‑Fi og Bluetooth. Denne handling kan ikke fortrydes."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Nulstil"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth og Wi‑Fi er blevet nulstillet"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Slet eSIM"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Mobilabonnementer opsiges ikke. Kontakt dit mobilselskab for at downloade nye SIM-kort."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Nulstil indstillinger"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Vil du nulstille alle netværksindstillinger? Denne handling kan ikke fortrydes."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Vil du rydde alle netværksindstillinger og rydde eSIM? Denne handling kan ikke fortrydes."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Nulstil indstillinger"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Vil du nulstille?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Gendannelse af netværk er ikke tilgængeligt for denne bruger"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Netværksindstillingerne er blevet nulstillet"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"SIM-kortene kan ikke ryddes"</string>
    <string name="reset_esim_error_msg" msgid="7279607120606365250">"eSIM kan ikke ryddes på grund af en fejl.\n\nGenstart din enhed, og prøv igen."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Ryd alle data (gendan fabriksindstillinger)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Ryd alle data (gendan fabriksindstillinger)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Musik"</li>\n<li>"Billeder"</li>\n<li>"Andre brugerdata"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIM"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Dette opsiger ikke automatisk dit mobilabonnement."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Alle dine personlige oplysninger og downloadede apps slettes. Denne handling kan ikke fortrydes."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Alle dine personlige oplysninger, bl.a. downloadede apps og SIM-kort, slettes. Denne handling kan ikke fortrydes."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Vil du rydde alle data?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Det er ikke muligt for denne bruger at gendanne fabriksindstillingerne"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Rydder"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Vent et øjeblik…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Indstillinger for opkald"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Konfigurer telefonsvarer, viderestilling af opkald, ventende opkald, opkalds-id"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Netdeling via USB"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Hotspot"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Netdeling via Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Netdeling"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Hotspot og netdeling"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Hotspot er slået til, netdeling"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Hotspot er slået til"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Netdeling"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Der kan ikke bruges netdeling eller hotspots, når Datasparefunktion er aktiveret"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Kun hotspot"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Kun USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Kun Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Kun 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">"Deler ikke internet med andre enheder"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Fra"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Netdeling via USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Netdeling via Bluetooth"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Netdeling via Ethernet"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Brug hotspot og netdeling til at give andre enheder adgang til internettet via din mobildataforbindelse. Apps kan også oprette et hotspot for at dele indhold med enheder i nærheden."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Brug hotspot og netdeling til at give andre enheder adgang til internettet via din Wi-Fi- eller mobildataforbindelse. Apps kan også oprette et hotspot til at dele indhold med enheder i nærheden."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Hjælp"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobilnetværk"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"Sms-app"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Vil du skifte sms-app?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Vil du bruge <xliff:g id="NEW_APP">%1$s</xliff:g> i stedet for <xliff:g id="CURRENT_APP">%2$s</xliff:g> som din standardapp til sms?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Vil du bruge <xliff:g id="NEW_APP">%s</xliff:g> som din sms-app?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Vil du skifte Wi-Fi-assistent?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Vil du bruge <xliff:g id="NEW_APP">%1$s</xliff:g> i stedet for <xliff:g id="CURRENT_APP">%2$s</xliff:g> til at administrere dine netværksforbindelser?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Vil du bruge <xliff:g id="NEW_APP">%s</xliff:g> til at administrere dine netværksforbindelser?"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Seneste lokationsanmodninger"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Lokation for arbejdsprofil"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Lokationstilladelse for apps"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Lokation er slået fra"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# ud af {total} apps har adgang til din lokation}one{# ud af {total} apps har adgang til din lokation}other{# ud af {total} apps har adgang til din lokation}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Seneste adgang"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Se alle"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Se oplysninger"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Ingen apps har anmodet om lokation for nylig"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Ingen apps har haft adgang til lokationen for nylig"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Højt batteriforbrug"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Lavt batteriforbrug"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Wi-Fi-scanning"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Tillad, at apps og tjenester altid kan søge efter Wi-Fi-netværk, også selvom Wi-Fi er deaktiveret. Dette kan f.eks. bruges til at forbedre lokationsbaserede funktioner og tjenester."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Bluetooth-scanning"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Tillad, at apps og tjenester altid kan søge efter enheder i nærheden, også selvom Bluetooth er deaktiveret. Dette kan f.eks. bruges til at forbedre lokationsbaserede funktioner og tjenester."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Lokationstjenester"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Lokationstjenester"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Anvend lokation"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Tidszonen kan ikke angives automatisk"</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">"Lokation eller Lokationstjenester er deaktiveret"</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">"Enhedens lokation skal aktiveres"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Hvis du vil angive tidszonen ved hjælp af din lokation, skal du aktivere lokation og derefter opdatere indstillingerne for tidszone"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Lokationsindstillinger"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Løs dette problem"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Luk"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Automatisk tidszone er deaktiveret"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Registrering af tidszone ved hjælp af lokation er deaktiveret"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Registrering af tidszone ved hjælp af lokation understøttes ikke"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Ændringer i forbindelse med registrering af tidszone ved hjælp af lokation er ikke tilladt"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Lokation kan anvendes til at angive tidszonen"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Se juridisk info, status, softwareversion"</string>
    <string name="legal_information" msgid="7509900979811934843">"Juridiske oplysninger"</string>
    <string name="manual" msgid="3651593989906084868">"Brugervejledning"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Certificeringer"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Brugervejledning i sikkerhed og regler"</string>
    <string name="copyright_title" msgid="83245306827757857">"Ophavsret"</string>
    <string name="license_title" msgid="8745742085916617540">"Licens"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licenser til Google Play-systemopdateringer"</string>
    <string name="terms_title" msgid="2071742973672326073">"Vilkår og betingelser"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"System WebView-licens"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Kreditering til baggrund"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Leverandører af satellitbilleder:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Brugervejledning"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Der er problemer med at indlæse brugervejledningen."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Tredjepartslicenser"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Der er problemer med at indlæse licenserne."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Indlæser..."</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Indlæser..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Angiv en adgangskode"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Indstil en adgangskode til arbejdsprofilen"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Angiv en pinkode"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Angiv en pinkode til arbejdsprofilen"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Indstil et mønster"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Få ekstra beskyttelse ved at angive et mønster til oplåsning af enheden"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Indstil et mønster til arbejdsprofilen"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Angiv adgangskode for at bruge fingeraftryk"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Angiv mønster for at bruge fingeraftryk"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Angiv en pinkode af hensyn til sikkerheden"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Angiv pinkode for at bruge fingeraftryk"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Angiv din adgangs­kode igen"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Angiv adgangskoden til arbejdsprofilen igen"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Angiv adgangskoden til din arbejdsprofil"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Bekræft dit mønster"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Angiv mønsteret til din arbejdsprofil"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Angiv din pinkode igen"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Angiv pinkoden til arbejdsprofilen igen"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Angiv pinkoden til din arbejdsprofil"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Adgangskoderne matcher ikke"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"Pinkoderne matcher ikke"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Tegn dit mønster igen"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Vælg oplåsningsmetode"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Adgangskoden er indstillet"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"Pinkoden er blevet indstillet"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Mønsteret er blevet indstillet"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Angiv backup for ansigtsoplåsning"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Angiv mønster for at bruge ansigtsoplåsning"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Angiv pinkode for at bruge ansigtsoplåsning"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Angiv en adgangs­kode for at bruge ansigt eller fingeraftryk"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Angiv et mønster for at bruge dit ansigt eller fingeraftryk"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Angiv en pinkode for at bruge dit ansigt eller fingeraftryk"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Har du glemt din adgangskode?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Har du glemt dit mønster?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Har du glemt din pinkode?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7401165571170203743">"Tegn dit mønster for at fortsætte"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Angiv din pinkode for at fortsætte"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Angiv din adgangskode for at fortsætte"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Tegn dit arbejdsmønster for at fortsætte"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Angiv pinkoden til din arbejdsprofil for at fortsætte"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Angiv adgangskoden til din arbejdsprofil for at fortsætte"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Brug mønsteret til din enhed for at opnå øget sikkerhed"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Angiv pinkoden til din enhed for at opnå øget sikkerhed"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Angiv adgangskoden til din enhed for at opnå øget sikkerhed"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Brug mønsteret til din arbejdsprofil for at opnå øget sikkerhed"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Angiv pinkoden til din arbejdsprofil for at opnå øget sikkerhed"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Angiv adgangskoden til din arbejdsprofil for at opnå øget sikkerhed"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Verificer mønster"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Verificer pinkode"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Verificer adgangskode"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Verificer identitet"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Angiv mønsteret til din anden enhed for at overføre dine Google-konti, indstillinger m.m. Dit mønster er krypteret."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Angiv pinkoden til din anden enhed for at overføre dine Google-konti, indstillinger m.m. Din pinkode er krypteret."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Angiv adgangskoden til din anden enhed for at overføre dine Google-konti, indstillinger m.m. Din adgangskode er krypteret."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Brug også mønster til at låse enheden op"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Brug også pinkode til at låse enheden op"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Brug også adgangskode til at låse enheden op"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Verificer mønster"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"Verificer pinkode"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Verificer adgangskode"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Brug mønsteret til din enhed for at fortsætte"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Angiv pinkoden til din enhed for at fortsætte"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Angiv adgangskoden til din enhed for at fortsætte"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Forkert pinkode"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Forkert adgangskode"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Forkert mønster"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Nødopkald"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Enhedssikkerhed"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Skift oplåsningsmønster"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Skift pinkode til oplåsning"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Tegn et mønster til at låse op"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Tryk på Menu for at få hjælp."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Slip, når du er færdig"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Forbind mindst <xliff:g id="NUMBER">%d</xliff:g> punkter. Prøv igen."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Mønstret blev registreret"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Tegn mønstret igen for at bekræfte"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Dit nye oplåsningsmønster"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Bekræft"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Tegn igen"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Ryd"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Fortsæt"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Oplåsningsmønster"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Kræv mønster"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Du skal tegne et mønster for at låse skærmen op"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Gør mønster synligt"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Forbedret beskyttelse af pinkode"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Deaktiver animationer, mens du angiver pinkoden"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Gør mønsteret til din profil synligt"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibrer ved tryk"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Afbryderknap låser straks"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Undtagen når den holdes oplåst af <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Angiv oplåsningsmønster"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Skift oplåsningsmønster"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Sådan tegnes et oplåsningsmønster"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"For mange mislykkede forsøg. Prøv igen om <xliff:g id="NUMBER">%d</xliff:g> sekunder."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Applikationen er ikke installeret på din telefon."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Beskyttelse af arbejdsprofil"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Skærmlås for arbejdsprofil"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Brug én lås"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Brug én skærmlås til arbejdsprofilen og enheden"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Vil du bruge én lås?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Din enhed anvender skærmlåsen for din arbejdsprofil. Arbejdspolitikkerne gælder for begge låse."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Skærmlåsen på din arbejdsprofil lever ikke op til din organisations sikkerhedskrav. Du kan bruge den samme skærmlås til både din enhed og din arbejdsprofil, men alle politikker for skærmlås på arbejdsprofilen gælder også for din enhed."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Brug én lås"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Brug én lås"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Den samme som enhedens skærmlås"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Administrer apps"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Appinfo"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Indstillinger for app"</string>
    <string name="install_applications" msgid="3921609656584369901">"Ukendte kilder"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Tillad alle appkilder"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Senest åbnede apps"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Se alle apps}one{Se alle apps (#)}other{Se alle # apps}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Kontakt din it-administrator"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Vedkommende kan hjælpe dig med at nulstille din pinkode, dit mønster eller din adgangskode"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Avancerede indstillinger"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Aktivér flere indstillinger"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Appinfo"</string>
    <string name="storage_label" msgid="2522307545547515733">"Lagerplads"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Åbn som standard"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Standard"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Skærmkompatibilitet"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Tilladelser"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Cache"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Ryd cache"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Cache"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 element}one{# element}other{# elementer}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Ryd adgang"</string>
    <string name="controls_label" msgid="8671492254263626383">"Kontrolelementer"</string>
    <string name="force_stop" msgid="2681771622136916280">"Tving til at standse"</string>
    <string name="archive" msgid="9074663845068632127">"Arkivér"</string>
    <string name="restore" msgid="7622486640713967157">"Gendan"</string>
    <string name="total_size_label" msgid="2052185048749658866">"I alt"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Appstørrelse"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Appdata på USB-lager"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Brugerdata"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Afinstaller"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Afinstaller for alle brugere"</string>
    <string name="install_text" msgid="4558333621516996473">"Installer"</string>
    <string name="disable_text" msgid="5146002260857428005">"Deaktiver"</string>
    <string name="enable_text" msgid="8570798764647110430">"Aktivér"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Ryd lagerplads"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Afinstaller opdateringer"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Tillad begrænsede indstillinger"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Nogle af de aktiviteter, du har valgt, åbnes som standard i denne app."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Du har valgt at tillade, at denne app opretter widgets og får adgang til deres data."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Der er ikke angivet nogen standarder."</string>
    <string name="clear_activities" msgid="488089228657585700">"Rydd standardpræferencer"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Denne app er muligvis ikke beregnet til din skærm. Her kan du administrere, hvordan den skal tilpasses til din skærm."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Spørg, når der startes"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Skaler app"</string>
    <string name="unknown" msgid="8192160131923461175">"Ukendt"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Sortér efter navn"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Sortér efter størrelse"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Seneste"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Hyppigste"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Vis kørende tjenester"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Cachelagrede processer"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Nødapp"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Nulstil app-præferencer"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Nulstil app-præferencer?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Dette nulstiller alle præferencer for:\n\n "<li>"Deaktiverede apps"</li>\n" "<li>"Deaktiverede appnotifikationer"</li>\n" "<li>"Standardapps til handlinger"</li>\n" "<li>"Begrænsning af baggrundsdata for apps"</li>\n<li>"Eventuelle begrænsede tilladelser"</li>\n<li>"Indstillinger for batteriforbrug"</li>\n\n"Du vil ikke miste nogen appdata."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Nulstil apps"</string>
    <string name="filter" msgid="9039576690686251462">"Filter"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Vælg filtreringsmuligheder"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Alle apps"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Deaktiverede apps"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Downloads"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Kørende"</string>
    <string name="not_installed" msgid="5074606858798519449">"Ikke installeret for denne bruger"</string>
    <string name="installed" msgid="2837449358488825884">"Installeret"</string>
    <string name="no_applications" msgid="985069304755391640">"Ingen apps."</string>
    <string name="internal_storage" msgid="999496851424448809">"Intern lagerplads"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Beregner størrelse igen..."</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Vil du slette appdata?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Denne apps data, herunder filer og indstillinger, fjernes permanent fra enheden"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"OK"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Annuller"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Slet"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Appen blev ikke fundet på listen over installerede apps."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Appens lagerplads kunne ikke ryddes."</string>
    <string name="computing_size" msgid="4915310659841174866">"Beregner..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Pakkestørrelsen kunne ikke beregnes."</string>
    <string name="version_text" msgid="7628938665256107608">"version <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Flyt"</string>
    <string name="archiving_failed" msgid="2037798988961634978">"Arkivering mislykkedes"</string>
    <string name="archiving_succeeded" msgid="7891249456483297845">"<xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> er arkiveret"</string>
    <string name="restoring_failed" msgid="3390531747355943533">"Gendannelsen mislykkedes"</string>
    <string name="restoring_succeeded" msgid="4967353965137524330">"<xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> er gendannet"</string>
    <string name="restoring_in_progress" msgid="7787443682651146115">"Gendanner <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"En anden migrering er allerede i gang."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Ikke nok lagerplads."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Appen findes ikke."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Installationsplaceringen er ikke gyldig."</string>
    <string name="system_package" msgid="7559476279008519360">"Systemopdateringerne kan ikke installeres på eksterne medier."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Appen til enhedsadministration kan ikke installeres på eksterne medier"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Tving til at standse?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Hvis du tvinger en app til at standse, kan det medføre, at den ikke fungerer korrekt."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Deaktiver appen"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Hvis du deaktiverer denne app, kan det medføre, at Android-apps og andre apps ikke fungerer korrekt. Vær opmærksom på, at du ikke kan slette denne app, da den er forudinstalleret på din enhed. Hvis du slår appen fra, deaktiveres og skjules den på din enhed."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Butik"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Info om appen"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Appen er installeret fra <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Flere oplysninger i <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Kører"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Aldrig brugt)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Lagerforbrug"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Genstarter"</string>
    <string name="cached" msgid="5379485147573438201">"Cachelagret baggrundsproces"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Intet kører."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Startet af app."</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> ledig"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> brugt"</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">"Bruger: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Fjernet bruger"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces og <xliff:g id="NUMSERVICES">%2$d</xliff:g> tjeneste"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proces og <xliff:g id="NUMSERVICES">%2$d</xliff:g> tjenester"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processer og <xliff:g id="NUMSERVICES">%2$d</xliff:g> tjeneste"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processer og <xliff:g id="NUMSERVICES">%2$d</xliff:g> tjenester"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Enhedens hukommelse"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Appens RAM-forbrug"</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">"Ledig"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Brugt"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Cachelagret"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> af RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Kørende app"</string>
    <string name="no_services" msgid="3898812785511572899">"Ikke aktiv"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Tjenester"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Processer"</string>
    <string name="service_stop" msgid="5712522600201308795">"Stop"</string>
    <string name="service_manage" msgid="3896322986828332075">"Indstillinger"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Denne tjeneste er startet af dens app. Hvis du stopper den, mislykkes appen."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Denne app kan ikke stoppes på en sikker måde. Hvis du stopper den, kan det slette noget af dit seneste arbejde."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Dette er en gammel appproces, der stadig kører i tilfælde af, at den bliver nødvendig igen. Der er normalt ingen grund til at stoppe den."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: Er i øjeblikket i brug. Tryk på Indstillinger for at håndtere det."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Hovedproces i brug."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Tjenesten <xliff:g id="COMP_NAME">%1$s</xliff:g> er i brug."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Udbyderen <xliff:g id="COMP_NAME">%1$s</xliff:g> er i brug."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Stop systemtjeneste?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Sprog, indtastning og bevægelser"</string>
    <string name="language_settings" msgid="8700174277543875046">"Sprog og indtastning"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Sprog"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Tastatur"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Du har ikke tilladelse til at ændre enhedens sprog."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Sprog og indtastning"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Værktøjer"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Tastatur og inputmetoder"</string>
    <string name="system_language" msgid="1146762166579643257">"Systemsprog"</string>
    <string name="phone_language" msgid="5986939176239963826">"Sprog"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automatisk erstatning"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Ret ord, der er stavet forkert"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Skriv aut. med stort"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Første bogstav i en sætning skrives med stort"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Foretag automatisk tegnsætning"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Indstillinger for fysisk tastatur"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Tryk på mellemrumstasten to gange for at indsætte punktum"</string>
    <string name="show_password" msgid="7101900779571040117">"Vis adgangskoder"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Vis kort tegnene, mens du skriver"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Denne stavekontrol kan muligvis indsamle al den tekst, som du skriver, også personlige data som adgangskoder og kreditkortnumre. Den kommer fra appen <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Vil du bruge denne stavekontrol?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Indstillinger"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Sprog"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Tastaturer"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Skærmtastatur"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Tilgængeligt skærmtastatur"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Administrer tastaturer på skærmen"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Valgmuligheder"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fysisk tastatur"</string>
    <string name="show_ime" msgid="4334255501724746849">"Brug skærmtastaturet"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Behold det på skærmen, mens det fysiske tastatur er aktivt"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Tastaturgenveje"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Vis liste over genveje"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastatur og værktøjer for arbejdsprofil"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Skærmtastatur til arbejdsprofil"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Standard"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Touchplade"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Touchplade og mus"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Markørens hastighed, bevægelser"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Tryk for at klikke"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Bevægelser på touchpladen"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Tilpas individuelle bevægelser til navigation af touchpladen"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Omvendt rulning"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Indholdet rykkes opad, når du ruller nedad"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Tryk nederst til højre"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Tryk nederst til højre på touchpladen for at se mere"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Markørens hastighed"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Se bevægelser på touchpladen"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Gå til startskærmen"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Stryg opad med tre fingre et vilkårligt sted på touchpladen"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Gå tilbage"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Stryg fra venstre eller højre med tre fingre"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Få vist seneste apps"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Stryg opad med tre fingre, hold dem nede, og løft dem"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Se notifikationer og kvikmenuen"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Stryg nedad med tre fingre på din startskærm"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Skift mellem apps"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Stryg til venstre eller højre med fire fingre"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Spring over"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Næste"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Genstart"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Udfør"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Gå tilbage"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Stryg til venstre eller højre med tre fingre"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Gå til startsiden"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Stryg opad med tre fingre"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Seneste apps"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Stryg opad med tre fingre, og hold derefter nede"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Notifikationer"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Stryg nedad med tre fingre"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Skift mellem apps"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Stryg til venstre eller højre med fire fingre"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Ændringstaster"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Rediger tasternes funktion"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Nulstil alle"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Standard"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Er du sikker på, at du vil nulstille alle ændringstasterne til standardindstillingerne?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Udfør"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Annuller"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Nulstil"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Vælg ændringstast"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Vælg en ny ændringstast til <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">"Tale"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Markørens hastighed"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Spillekontroller"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Omdiriger vibration"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Send vibration til spillecontroller, når den er tilsluttet"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Vælg tastaturlayout"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Konfigurer tastaturlayout"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Tryk på Ctrl-Mellemrum for at skifte"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Standard"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Tastaturlayout"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Layout for fysisk tastatur"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Personlig ordbog"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Personlig ordbog til arbejdsprofil"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Tilføj ord, der skal bruges i apps som f.eks. Stavekontrol"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Tilføj"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Føj til ordbog"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Sætning"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Flere muligh."</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Færre muligh."</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Ord:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Genvej:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Sprog:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Skriv et ord"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Valgfri genvej"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Rediger ord"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Rediger"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Slet"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Du har ikke nogen ord i brugerordbogen. Hvis du vil tilføje et ord, kan du trykke på knappen Tilføj (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"For alle sprog"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Flere sprog..."</string>
    <string name="testing" msgid="6294172343766732037">"Tester"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Skærmtastatur, værktøjer"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Skærmtastatur, fysisk tastatur, værktøjer"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fysisk tastatur"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Layout"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Vælg gadget"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Vælg widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Vil du oprette en widget og tillade adgang?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Når du har oprettet din widget, kan appen tilgå alt, hvad der vises.\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">"Tillad altid, at <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> opretter widgets og får adgang til deres data"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Brugerstatistikker"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Sortér efter tidsforbrug"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Sortér efter sidst anvendt"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Sortér efter appnavn"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Sidst anvendt"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Brugstid"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Hjælpefunktioner"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Indstillinger for hjælpefunktioner"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Skærm, interaktion, lyd"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Synsindstillinger"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Du kan tilpasse denne enhed, så den passer til dine behov. Disse hjælpefunktioner kan ændres senere under Indstillinger."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Skift skriftstørrelse"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Skærmlæser"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Undertekster"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Lyd"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Generelt"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Visning"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Farve og bevægelse"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Gør skærmen mørkere"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaktionsstyring"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Tidsrelaterede styringselementer"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Systemstyring"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Apps, du har downloadet"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Eksperimentel"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Aktivering og deaktivering af demofunktioner"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filtrering af Bluetooth HCI snoop log"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Indstil filtre"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Deaktiver og aktivér Bluetooth for at få ændringerne til at træde i kraft"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"Filtrering af Bluetooth HCI snoop log PBAP"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"Filtrering af Bluetooth HCI snoop log MAP"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Angiv filtreringstilstand (deaktiver og aktivér Bluetooth for at få ændringer til at træde i kraft)."</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Angiv tilstanden for Bluetooth HCI snoop log til Filtreret er aktiveret for at ændre denne mulighed"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Skærmlæser primært til blinde og svagtseende brugere"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Tryk på elementer på din skærm for at få dem læst op"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Præferencer for undertekster"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Om præferencer for undertekster"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Få flere oplysninger om præferencer for undertekster"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Forstørrelse"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Genvej til forstørrelse"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Forstør skrift"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Luppen følger teksten, når du skriver"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Hold aktiveret ved skift af app"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Forstørrelse forbliver aktiveret og zoomer ud, når du skifter app"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Joystick"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Aktivér luppen, og flyt den ved hjælp af et joystick på skærmen. Tryk på luppen, hold fingeren nede, og træk i joysticket for at flytte luppen. Tryk på selve joysticket for at trække i det."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Om forstørrelse"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Få flere oplysninger om forstørrelse"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Type af forstørrelse"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Forstør hele skærmen, en del af skærmen, eller skift mellem begge valgmuligheder"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Fuld skærm"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Delvis skærm"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Skift mellem fuld skærm og delvis skærm"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Vælg, hvordan du vil forstørre"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Forstør hele skærmen"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Forstør en del af skærmen"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Skift mellem fuld skærm og delvis skærm"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Tryk på skifteknappen for at skifte mellem de to valgmuligheder"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Vil du skifte til knappen til hjælpefunktioner?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Hvis du bruger tre tryk til at forstørre en del af skærmen, forsinkes indtastning og andre handlinger.\n\nKnappen til hjælpefunktioner svæver over andre apps på skærmen. Tryk på den for at forstørre."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Skift til knappen til hjælpefunktioner"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Brug tre tryk"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Dette kan gøre dit tastatur langsommere"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Når du forstørrer en del af skærmen ved at trykke tre gange, kan du opleve problemer over tastaturet.\n\nHvis du vil undgå dette, kan du ændre din forstørrelsesgenvej til noget andet end at trykke tre gange.\n"<annotation id="link">"Skift indstilling"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Fortsæt alligevel"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Annuller"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Indstillinger for forstørrelse"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Brug en genvej til forstørrelse"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Brug en genvej til forstørrelse med tre tryk"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Om <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Skærmstørrelse og tekst"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Juster, hvordan tekst vises"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Emne: Designs til varmluftballoner"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Fra: Jens"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Godmorgen\n\nJeg ville bare lige høre, hvordan det går med dine designs. Vil de være klar, inden vi går i gang med at bygge de nye balloner?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Nulstil indstillinger"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Skærmindstillinger for størrelse og tekst er blevet nulstillet"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Skal indstillingerne for skærmstørrelse og tekst nulstilles?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Nulstil"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Har du nogen planer for weekenden?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Jeg skal på stranden. Vil du med?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Valgmuligheder"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Zoom ind på skærmen"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Tryk tre gange for at zoome ind"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Tryk på en knap for at zoome"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Zoom hurtigt ind på skærmen for at forstørre indhold"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Sådan zoomer du ind:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Brug genvejen til at starte forstørrelse&lt;br/&gt; {1,number,integer}. Tryk på skærmen&lt;br/&gt; {2,number,integer}. Træk med to fingre for at navigere rundt på skærmen&lt;br/&gt; {3,number,integer}. Knib med to fingre for at zoome ind eller ud&lt;br/&gt; {4,number,integer}. Brug genvejen til at stoppe forstørrelse&lt;br/&gt;&lt;br/&gt;&lt;b&gt;Sådan zoomer du midlertidigt ind:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Sørg for, at forstørrelsestypen er indstillet til fuld skærm&lt;br/&gt; {1,number,integer}. Brug genvejen til at starte forstørrelse&lt;br/&gt; {2,number,integer}. Hold fingeren nede et vilkårligt sted på skærmen&lt;br/&gt; {3,number,integer}. Træk fingeren for at navigere rundt på skærmen&lt;br/&gt; {4,number,integer}. Løft fingeren for at stoppe forstørrelse"</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Når forstørrelse er aktiveret, kan du zoome ind på skærmen.\n\n"<b>"Hvis du vil zoome"</b>", skal du åbne forstørrelse og derefter trykke et vilkårligt sted på skærmen.\n"<ul><li>"Træk med to eller flere fingre for at rulle"</li>\n<li>"Knib sammen med to eller flere fingre for at justere zoomniveauet"</li></ul>\n\n<b>"Hvis du vil zoome midlertidigt"</b>", skal du åbne forstørrelse og holde fingeren nede et vilkårligt sted på skærmen.\n"<ul><li>"Træk for at udforske forskellige dele af skærmen"</li>\n<li>"Løft fingeren for at zoome ud"</li></ul>\n\n"Du kan ikke zoome ind på tastaturet eller navigationslinjen."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Side <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> af <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Brug knappen til hjælpefunktioner til at åbne"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Hold lydstyrkeknapperne nede for at åbne"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Tryk tre gange på skærmen for at åbne"</string>
    <string name="accessibility_tutorial_dialog_title_two_finger_double" msgid="3912970760484557646">"Tryk to gange på skærmen med to fingre for at åbne"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Brug en bevægelse til at åbne"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Brug bevægelsen for hjælpefunktioner"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Tryk på knappen til hjælpefunktioner <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> nederst på skærmen for at bruge denne funktion.\n\nDu kan skifte mellem funktioner ved at holde knappen til hjælpefunktioner nede."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Tryk på knappen til hjælpefunktioner på din skærm for at bruge denne funktion."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Hold begge lydstyrkeknapper nede for at bruge denne funktion."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Du kan starte og stoppe forstørrelse ved at trykke tre gange på skærmen."</string>
    <string name="accessibility_tutorial_dialog_message_two_finger_triple" msgid="860548190334486449">"Du kan starte og stoppe forstørrelse ved at trykke to gange på skærmen med to fingre."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Stryg opad fra bunden af skærmen med to fingre for at bruge denne funktion.\n\nDu kan skifte mellem funktioner ved at stryge opad med to fingre og holde dem nede."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Stryg opad fra bunden af skærmen med tre fingre for at bruge denne funktion.\n\nDu kan skifte mellem funktioner ved at stryge opad med tre fingre og holde dem nede."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Stryg opad fra bunden af skærmen med to fingre for at bruge en hjælpefunktion.\n\nDu kan skifte mellem funktioner ved at stryge opad med to fingre og holde dem nede."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Stryg opad fra bunden af skærmen med tre fingre for at bruge en hjælpefunktion.\n\nDu kan skifte mellem funktioner ved at stryge opad med tre fingre og holde dem nede."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"OK"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="6797349445794031781">"Indstillinger for knap"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Genvej for <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Knap til hjælpefunktioner"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Bevægelse for hjælpefunktioner"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Stryg op med to fingre"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Stryg op med tre fingre"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Tryk på knappen til hjælpefunktioner"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Brug bevægelsen for hjælpefunktioner"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Tryk på knappen til hjælpefunktioner <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> nederst på skærmen.\n\nDu kan skifte mellem funktioner ved at holde knappen til hjælpefunktioner nede."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Stryg opad fra bunden af skærmen med to fingre.\n\nDu kan skifte mellem funktioner ved at stryge opad med to fingre og holde dem nede."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Stryg opad fra bunden af skærmen med tre fingre.\n\nDu kan skifte mellem funktioner ved at stryge opad med tre fingre og holde dem nede."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Flere valgmuligheder"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Få flere oplysninger om <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Hold lydstyrkeknapperne nede"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"hold lydstyrkeknapperne nede"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Hold begge lydstyrkeknapper nede"</string>
    <string name="accessibility_shortcut_edit_dialog_title_two_finger_double_tap" msgid="2271778556854020996">"Tryk to gange på skærmen med to fingre"</string>
    <string name="accessibility_shortcut_two_finger_double_tap_keyword" msgid="2971265341474137433">"tryk to gange på skærmen med to fingre"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_two_finger_double_tap" msgid="8262165091808318538">"Tryk hurtigt på skærmen {0,number,integer} gange med to fingre"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Tryk tre gange på skærmen"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"tryk tre gange på skærmen"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Tryk hurtigt på skærmen {0,number,integer} gange. Denne genvej kan gøre din enhed langsommere"</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Avanceret"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Knappen til hjælpefunktioner er angivet til <xliff:g id="SERVICE">%1$s</xliff:g>. Hvis du vil bruge forstørrelse, skal du trykke på knappen til hjælpefunktioner, holde fingeren nede og derefter vælge forstørrelse."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Bevægelsen for hjælpefunktioner er indstillet til <xliff:g id="SERVICE">%1$s</xliff:g>. Hvis du vil bruge forstørrelse, kan du stryge opad med to fingre fra bunden af skærmen og holde dem nede. Vælg derefter forstørrelse."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Genvej via lydstyrkeknapperne"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Indstillinger for genvej"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Genvej på låseskærmen"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Tillad, at genvej til funktionen kan aktiveres via låseskærmen. Hold begge lydstyrkeknapper nede i et par sekunder."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Knap til hjælpefunktioner"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Knap til hjælpefunktioner og bevægelser for hjælpefunktioner"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Få hurtigt adgang til hjælpefunktioner på enhver skærm"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Om knappen til hjælpefunktioner"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Om knappen til hjælpefunktioner og bevægelser for hjælpefunktioner"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Få flere oplysninger om knappen til hjælpefunktioner og bevægelser for hjælpefunktioner"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Brug af knappen til hjælpefunktioner. Bevægelsen er ikke tilgængelig med navigation med tre knapper."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Få hurtigt adgang til hjælpefunktioner"</string>
    <string name="accessibility_button_gesture_description" msgid="1141723096904904336">"&lt;b&gt;Sådan kommer du i gang&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Gå til indstillinger for hjælpefunktioner&lt;br/&gt; {1,number,integer}. Vælg en funktion, og tryk på genvejen&lt;br/&gt; {2,number,integer}. Vælg, om du vil bruge en knap eller en bevægelse for at tilgå funktionen&lt;br/&gt;"</string>
    <string name="accessibility_button_description" msgid="7669538706120092399">"&lt;b&gt;Sådan kommer du i gang&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Gå til indstillinger for hjælpefunktioner&lt;br/&gt; {1,number,integer}. Vælg en funktion, og tryk på genvejen&lt;br/&gt; {2,number,integer}. Vælg den knap, du vil bruge for at tilgå funktionen&lt;br/&gt;"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Brug knap eller bevægelse"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Lokation"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Størrelse"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Udton, når funktionen ikke bruges"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Udtones efter et par sekunder, så det bliver nemmere at se din skærm"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Gennemsigtig, når funktionen ikke bruges"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Gennemsigtig"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Ikke-gennemsigtig"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst med høj kontrast"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Skift tekstfarven til sort eller hvid. Dette maksimerer kontrasten med baggrunden."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Opdater skærmforstørrelse automatisk"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Opdater skærmforstørrelsen på appovergange"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Afbryderknap afslutter opkald"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Stor musemarkør"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Gør musemarkøren mere synlig"</string>
    <string name="accessibility_force_invert_title" msgid="5015366813138748407">"Brug mørkt tema i alle apps"</string>
    <string name="accessibility_force_invert_summary" msgid="1882329675950887268">"Gælder for apps uden eget mørkt tema. Nogle apps kan have visningsproblemer, f.eks. ombyttede farver."</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Fjern animationer"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Begrænser bevægelse på skærmen"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Monolyd"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Kombiner kanaler ved afspilning af lyd"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Lydbalance"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Venstre"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Højre"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Standard"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sekunder"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sekunder"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minut"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minutter"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Handlingstid (timeout for Hjælpefunktioner)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Om handlingstid (timeout for Hjælpefunktioner)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Få flere oplysninger om handlingstid (timeout for Hjælpefunktioner)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Handlingstid"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Denne tidsbaserede præference understøttes ikke af alle apps"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Vælg, hvor længe der skal vises midlertidige meddelelser, som beder dig om at foretage en handling"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Forsinkelse for Tryk og hold"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Ombytning af farver"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Brug ombytning af farver"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Genvej til ombytning af farver"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Funktionen Ombytning af farver gør lyse skærme mørke. Den kan også gøre mørke skærme lyse."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Vær opmærksom på følgende&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Farverne ændres i medier og på billeder&lt;/li&gt; &lt;li&gt; Ombytning af farver fungerer i alle apps&lt;/li&gt; &lt;li&gt; Hvis du vil bruge en mørk baggrund, kan du bruge Mørkt tema i stedet&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_action_label_panel_slice" msgid="1313725957071602932">"angive indstillinger"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Autoklik (dvæletid)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Om automatisk klik (dvæletid)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Få flere oplysninger om autoklik (dvæletid)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Du kan indstille en tilknyttet mus til at klikke automatisk, når markøren holder op med at bevæge sig i en angivet mængde tid"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Autoklik kan være en nyttig funktion, hvis det er svært at klikke med musen"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Autoklik er deaktiveret"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Kort"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sekunder"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Mellem"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sekunder"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Lang"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sekund"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Tilpasset"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Kortere"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Længere"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Varighed af automatisk klik"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibration og haptik"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Tilpas vibrationsstyrken til forskellige brugsformer"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Aktiveret"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Deaktiveret"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Indstillingen er deaktiveret, fordi enheden er sat på lydløs"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Opkald"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Notifikationer og alarmer"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Interaktive haptiske effekter"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Brug vibration og haptik"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Vibration for alarm"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Vibration for medier"</string>
    <string name="accessibility_keyboard_vibration_title" msgid="7559967730626765441">"Tastaturvibration"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibration ved opkald"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibration ved notifikation"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Feedback ved tryk"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Brug <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Åbn <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> er føjet til kvikmenuen. Du kan altid stryge nedad for at slå funktionen til eller fra."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Du kan også føje <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> til kvikmenuen fra toppen af skærmen"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Farvekorrigering er føjet til kvikmenuen. Du kan altid stryge nedad for at slå funktionen til eller fra."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Du kan også føje farvekorrigering til kvikmenuen fra toppen af skærmen"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Farvekorrigering er føjet til kvikmenuen. Du kan altid stryge nedad for at slå funktionen til eller fra."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Du kan også føje farvekorrigering til kvikmenuen fra toppen af skærmen"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Ekstra dæmpet belysning er føjet til kvikmenuen. Du kan altid stryge nedad for at slå funktionen til eller fra."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Du kan også føje ekstra dæmpet belysning til kvikmenuen fra toppen af skærmen"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Enhåndstilstand er føjet til kvikmenuen. Du kan altid stryge nedad for at slå funktionen til eller fra."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Du kan også føje enhåndstilstand til kvikmenuen fra toppen af skærmen"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"En skriftstørrelse blev føjet til kvikmenuen. Du kan til enhver tid stryge nedad for at ændre skriftstørrelsen."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Afvis"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Brug farvekorrigering"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Genvej til farvekorrigering"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Om farvekorrigering"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Få flere oplysninger om farvekorrigering"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Om ombytning af farver"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Få flere oplysninger om ombytning af farver"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Vis undertekster"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Kun til understøttet app"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Undertekststørrelse og -type"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Tekststørrelsen <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Flere valgmuligheder"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Tilpas størrelsen på og stilarten for undertekster, så de bliver nemmere at læse"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Disse præferencer for undertekster understøttes ikke af alle medieapps"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Knap til hjælpefunktioner"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Stryg opad med to fingre fra bunden af skærmen"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Hold lydstyrketasterne inde"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tryk tre gange på skærmen"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Fortsæt"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Høreapparater"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Du kan bruge høreapparater, cochlear-implantater og andre lydforstærkere sammen med din telefon"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Ingen høreapparater er tilsluttet"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Tilføj høreapparater"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Par høreapparater"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Tryk på høreapparaterne på næste skærm. Du skal muligvis parre venstre og højre høreapparat separat.\n\nSørg for, at dine høreapparater er tændt og klar til at blive parret."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> er aktiv"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> –kun venstre"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> – kun højre"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> –venstre og højre"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"Mindst 1 <xliff:g id="DEVICE_NAME">%1$s</xliff:g> mere"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Par ny enhed"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"Om \"Par ny enhed\""</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Høreapparater"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Gemte enheder"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Indstillinger for høreapparatet"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Genvej til høreapparat"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Høreapparatskompatibilitet"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Forbedrer kompatibiliteten med teleslynge og reducerer uønsket støj"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Om høreapparater"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Sørg for, at dit høreapparat er tændt og klar til at blive parret"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Par høreapparat"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Tilgængelige høreapparater"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Kan du ikke se dit høreapparat?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Se flere enheder"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Lydjustering"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Synstolkning"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Hør en beskrivelse af, hvad der sker på skærmen, i understøttede film og tv-serier"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"synstolkning, lyd, beskrivelse, stærkt nedsat syn,"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Genvejen er aktiveret"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Fra"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Til"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Fra"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Kører ikke. Tryk for at få flere oplysninger."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Denne tjeneste fungerer ikke korrekt."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Genveje til hjælpefunktioner"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Vis i Kvikmenu"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Rød-grøn"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Rød-grøn"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Blå-gul"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Gråtoner"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Farvesvaghed for grøn, deuteranomali"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Farvesvaghed for rød, protanomali"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomali"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Ekstra dæmpet belysning"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Ekstra dæmpet belysning af skærm"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Genvej til ekstra dæmpet belysning"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Om ekstra dæmpet belysning"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Nedton din skærm, så din læseoplevelse bliver mere behagelig"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensitet"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Mørkere"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Lysere"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Slå ikke fra efter genstart af enheden"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Kort ({time} sekund)}one{Kort ({time} sekund)}other{Kort ({time} sekunder)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Mellem ({time} sekund)}one{Mellem ({time} sekund)}other{Mellem ({time} sekunder)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Lang ({time} sekund)}one{Lang ({time} sekund)}other{Lang ({time} sekunder)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} sekund}one{{time} sekund}other{{time} sekunder}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Indstillinger"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Til"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Fra"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Forhåndsvisning"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standardindstillinger"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Sprog"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Tekststørrelse"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Underteksttype"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Tilpassede valgmuligheder"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Baggrundsfarve"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Baggrundens gennemsigtighed"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Tekstvinduets farve"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Tekstvinduets gennemsigtighed"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Tekstfarve"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Tekstens gennemsigtighed"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Rammens farve"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Rammetype"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Skrifttypefamilie"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Underteksterne vil se sådan ud"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Standard"</string>
    <string name="color_title" msgid="2511586788643787427">"Farve"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Standard"</string>
    <string name="color_none" msgid="3703632796520710651">"Ingen"</string>
    <string name="color_white" msgid="1896703263492828323">"Hvid"</string>
    <string name="color_gray" msgid="8554077329905747877">"Grå"</string>
    <string name="color_black" msgid="9006830401670410387">"Sort"</string>
    <string name="color_red" msgid="5210756997426500693">"Rød"</string>
    <string name="color_green" msgid="4400462091250882271">"Grøn"</string>
    <string name="color_blue" msgid="4997784644979140261">"Blå"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Grønblå"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Gul"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Lyslilla"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Vil du give <xliff:g id="SERVICE">%1$s</xliff:g> fuld kontrol over din enhed?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> har brug for at:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Indstillinger kan ikke verificere dit svar, fordi en app tilslører tilladelsesanmodningen."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> anmoder om fuld kontrol over denne enhed. Tjenesten kan læse skærmen og handle på vegne af brugere med særlige behov. Dette kontrolomfang er ikke passende for de fleste apps."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Fuld kontrol er velegnet til apps, der hjælper dig med hjælpefunktioner, men ikke de fleste apps."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Se og styre skærm"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Den kan læse alt indhold på skærmen og vise indhold oven på andre apps."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Se og udføre handlinger"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Den kan spore dine interaktioner med en app eller en hardwaresensor og interagere med apps på dine vegne."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Tillad"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Afvis"</string>
    <string name="accessibility_dialog_button_stop" msgid="7584815613743292151">"Slå fra"</string>
    <string name="accessibility_dialog_button_cancel" msgid="8625997437316659966">"Slå ikke fra"</string>
    <string name="disable_service_title" msgid="8178020230162342801">"Vil du slå <xliff:g id="SERVICE">%1$s</xliff:g> fra?"</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Der er ikke installeret nogen tjenester"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Der er ikke valgt nogen tjeneste"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Ingen beskrivelse til rådighed."</string>
    <string name="settings_button" msgid="2195468788019730377">"Indstillinger"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"lysfølsomhed, fotofobi, mørkt tema, migræne, hovedpine, læsetilstand, nattilstand, dæmp lyset, hvidt punkt"</string>
    <string name="keywords_accessibility" msgid="8593989878379366798">"syn, hørelse, blind, døv, mobilitet, fingerbevægelighed, hjælp, hjælpefunktion, brugervenlighed, nem adgang, hånd, assistance"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Forstørrelse af vindue, zoom, forstørrelse, nedsat syn, forstør, gør større"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Tekster, undertekster for hørehæmmede, undertekster, Livetransskribering, hørehæmmet, hørelsestab, CART, indtaling, undertekst"</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">"skærmstørrelse, stor skærm"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Høj kontrast, nedsat syn, fed skrifttype, fed tekst"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"skift farve"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"gør skærmen mørk, gør skærmen lys"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"farvekontrast"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="6811744211216280998">"mobilitet, ekstern mus, hovedmus, adaptiv mus, kørestol, joystick"</string>
    <string name="keywords_hearing_aids" msgid="4657889873249157071">"høreapparater, hørehæmmet, tab af hørelse, cochlear-implantater, lydforstærkere, lydprocessorer, produkter til lydforstærkning"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"hørehæmmet, hørelsestab, undertekster, teleprinter, tty"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="keywords_3_button_navigation" msgid="436361965016404218">"tre knapper"</string>
    <string name="keywords_touch_and_hold_delay" msgid="7854640156419599912">"fingerbevægelighed, mobilitet, ældre, gigt, rsi, slagtilfælde, ufrivillige bevægelser, multipel sklerose, spastisk lammelse, rystelser, belastningsskade, hånd"</string>
    <string name="keywords_accessibility_timeout" msgid="8903766864902000346">"forsinkelse, fingerbevægelighed, ældre"</string>
    <string name="print_settings" msgid="8519810615863882491">"Udskrivning"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Fra"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 udskrivningstjeneste er aktiveret}one{# udskrivningstjeneste er aktiveret}other{# udskrivningstjenester er aktiveret}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 udskriftsjob}one{# udskriftsjob}other{# udskriftsjobs}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Udskrivningstjenester"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Der er ikke installeret nogen tjenester"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Der blev ikke fundet nogen printere"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Indstillinger"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Tilføj printere"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Til"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Fra"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Tilføj tjeneste"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Tilføj printer"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Søg"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Søger efter printere"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Tjenesten er deaktiveret"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Udskriftsjobs"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Udskriftsjob"</string>
    <string name="print_restart" msgid="4424096106141083945">"Genstart"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Annuller"</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">"Konfigurerer <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> udskrives"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> annulleres"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"<xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> kunne ikke udskrives"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Printeren har blokeret <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Søgefeltet er vist"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Søgefeltet er skjult"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Flere oplysninger om denne printer"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Batteri"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Hvad der har brugt batteriet"</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">"<xliff:g id="REMAIN">%1$s</xliff:g> tilbage"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> til batteriet er opladt"</string>
    <string name="power_usage_detail_screen_time" msgid="6027274749498485283">"Skærmtid"</string>
    <string name="power_usage_detail_background_time" msgid="3661437083554322691">"Tid i baggrunden"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Lavt batteriniveau"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Giv appen tilladelse til at køre i baggrunden"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Vil du begrænse baggrundsaktiviteten?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Hvis du begrænser en apps baggrundsaktivitet, kan det medføre, at den ikke fungerer korrekt"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Appen kan ikke begrænses, da batterioptimering er deaktiveret.\n\nAktivér batterioptimering for at begrænse appen."</string>
    <string name="manager_battery_usage_category_title" msgid="1493303237531629961">"Administrer batteriforbrug"</string>
    <string name="manager_battery_usage_allow_background_usage_title" msgid="6294649996820358852">"Tillad brug i baggrunden"</string>
    <string name="manager_battery_usage_allow_background_usage_summary" msgid="8021153755201340819">"Aktivér for at få opdateringer i realtid, deaktiver for at spare på batteriet"</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Ubegrænset"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimeret"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Begrænset"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Tillad batteriforbrug i baggrunden uden begrænsninger. Dette medfører muligvis større batteriforbrug."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimer baseret på dit forbrug. Anbefales til de fleste apps."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Begræns batteriforbrug ved brug i baggrunden. Appen fungerer muligvis ikke som forventet. Notifikationer forsinkes muligvis."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Hvis du ændrer, hvordan en app bruger dit batteri, kan det påvirke appens ydeevne."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Denne app kræver <xliff:g id="STATE">%1$s</xliff:g> batteriforbrug."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"ubegrænset"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimeret"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Få flere oplysninger om valgmuligheder for batteriforbrug"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Brug af skærmen siden fuld opladning"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Batteriforbrug"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Detaljeret historik"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Batteriforbrug"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Se forbrug for de seneste 24 timer"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Se forbrug siden sidste fulde opladning"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Appens batteriforbrug"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Brugsdetaljer"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Juster strømforbrug"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Inkluderede pakker"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Apps kører normalt"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Lavt batteriniveau"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Aktivér Batterisparefunktion for at forlænge batteritiden"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Forlæng batteritid"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Aktivér batteriadministration"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Aktivér batterisparefunktionen"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Batteriet aflades muligvis hurtigere end normalt"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Batterisparefunktion – TIL"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Få flere oplysninger om batterisparefunktionen"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Nogle funktioner kan være begrænsede"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Højere batteriforbrug"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Se apps med højest forbrug"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Opladning optimeres for at beskytte dit batteri"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Opladning optimeres for at hjælpe med at forlænge batteriets levetid"</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"Opladningen optimeres for at beskytte dit batteri"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"Opladningen optimeres, mens enheden er i dockingstationen, for at hjælpe med at forlænge batteriets levetid"</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"Opladning er optimeret for at beskytte dit batteri"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"Opladning er optimeret, mens enheden er i dockingstationen, for at hjælpe med at forlænge batteriets levetid"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"Lader helt op"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"For at beskytte dit batteri optimeres opladningen, næste gang din tablet sættes i dockingstationen"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Få flere oplysninger om, hvad det betyder, når opladning er sat på pause"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Genoptag opladning"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Omfatter batterikrævende aktivitet i baggrunden"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Begræns # app}one{Begræns # app}other{Begræns # apps}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} er for nylig blevet begrænset}one{# app er for nylig blevet begrænset}other{# apps er for nylig blevet begrænset}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} bruger meget batteri i baggrunden}one{# app bruger meget batteri i baggrunden}other{# apps bruger meget batteri i baggrunden}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Denne app kan ikke køre i baggrunden}one{Denne app kan ikke køre i baggrunden}other{Disse apps kan ikke køre i baggrunden}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Vil du begrænse appen?}one{Vil du begrænse # app?}other{Vil du begrænse # apps?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Du kan spare på batteriet ved at forhindre <xliff:g id="APP">%1$s</xliff:g> i at bruge batteri i baggrunden. Appen fungerer muligvis ikke korrekt, og notifikationer kan være forsinkede."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Du kan spare på batteriet ved at forhindre disse apps i at bruge batteri i baggrunden. Begrænsede apps fungerer muligvis ikke korrekt, og notifikationer kan være forsinkede.\n\nApps:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Du kan spare på batteriet ved at forhindre disse apps i at bruge batteri i baggrunden. Begrænsede apps fungerer muligvis ikke korrekt, og notifikationer kan være forsinkede.\n\nApps:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Begræns"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Vil du fjerne begrænsningen?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Denne app vil kunne bruge batteri i baggrunden. Enheden løber muligvis tør for batteri hurtigere end forventet."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Fjern"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Annuller"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Oplad helt"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Problem med opladertilbehør"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Få flere oplysninger om opladning med inkompatible strømadaptere"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Batteriadministration"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Administrer automatisk apps"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Når batteriadministrator registrerer, at der er apps, som dræner batteriet, får du mulighed for at begrænse disse apps. Begrænsede apps fungere muligvis ikke korrekt, og notifikationer kan være forsinkede."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Begrænsede apps"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Begrænser batteriforbruget for # app}one{Begrænser batteriforbruget for # app}other{Begrænser batteriforbruget for # apps}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Blev begrænset <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Disse apps begrænses i forhold til batteriforbrug i baggrunden. De fungerer muligvis ikke som forventet, og notifikationer kan blive forsinket."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Brug batteriadministration"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Registrer, når apps dræner batteriet"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Registrerer, når apps dræner batteriet"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Registrerer, når apps dræner batteriet"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# app er begrænset}one{# app er begrænset}other{# apps er begrænset}}"</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">"Der er problemer med at læse batteriniveauet."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Tryk for at få flere oplysninger om denne fejl"</string>
    <string name="power_screen" msgid="4596900105850963806">"Skærm"</string>
    <string name="power_cpu" msgid="1820472721627148746">"CPU"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Lommelygte"</string>
    <string name="power_camera" msgid="4778315081581293923">"Kamera"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Mobilnetværk"</string>
    <string name="power_phone" msgid="2768396619208561670">"Stemmeopkald"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Skærmtid <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> anvendt af <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> af det samlede batteriforbrug"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Siden sidste fulde opladning"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Sidste fulde opladning"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"En fuld opladning holder omkring"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Den resterende batteritid er omtrentlig og kan ændre sig afhængigt af brug"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Batteriforbrug"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Intet forbrug siden sidste fulde opladning"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Ikke brugt i løbet af de seneste 24 timer"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"siden sidste fulde opladning"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Systemapps"</string>
    <string name="battery_usage_uninstalled_apps" msgid="8170405012552803662">"Afinstallerede apps"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Andre"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Estimeret resterende tid"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Indtil den er fuldt opladet"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Skønnet kan ændres afhængigt af forbrug"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Medieserver"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Appoptimering"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Netdeling"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Fjernede apps"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Batterisparefunktion"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Aktivér automatisk"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Ingen tidsplan"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Baseret på din rutine"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Aktiveres baseret på din rutine"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Baseret på procent"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Batterisparefunktion aktiveres, hvis dit batteri ser ud til at løbe tør inden det tidspunkt, hvor du normalt oplader det"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Aktiveres ved <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Angiv en tidsplan"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Forlæng batteritiden"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Deaktiver, når enheden er opladet"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Sluk ved <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Batterisparefunktion deaktiveres, når batteriet når op på <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Aktivér"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Brug batterisparefunktionen"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Slå automatisk til"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Aldrig"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"ved batteriniveau på <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Batteriniveau"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Vis batteriniveau på statusbjælken"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Batteriniveau siden sidste fulde opladning"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Batteriniveau for de seneste 24 timer"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Appforbrug siden sidste fulde opladning"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Appforbrug for de seneste 24 timer"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Systemforbrug siden sidste fulde opladning"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Systemforbrug for de seneste 24 timer"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Systemforbrug for <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Appforbrug for <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Systemforbrug siden sidste fulde opladning <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Appforbrug siden sidste fulde opladning <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"I alt: Under et minut"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Baggrund: Under et minut"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Skærmtid: Under et minut"</string>
    <string name="power_usage_time_less_than_one_minute" msgid="8407404329381010144">"Mindre end et minut"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"I alt: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Baggrund: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Skærmtid: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Data om batteriforbrug bliver tilgængelige, et par timer efter at enheden er fuldt opladet"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"nu"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"<xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g>-<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">"Diagram over batteriforbrug"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Diagram med batteriforbrug pr. dag"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Diagram med batteriforbrug pr. time"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Batteriforbrug siden sidste fulde opladning"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Batteriforbrug for <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Skærmtid siden sidste fulde opladning"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Skærmtid for <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Vis efter apps"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Vis efter systemer"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"Mere end <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_cycle_count_footer" msgid="3642121059800373545">"På grund af kvalitetstjek inden afsending er cyklusantallet muligvis ikke nul, første gang du bruger enheden"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Processtatistikker"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Nørdede statistikker om kørende processer"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"hukommelse brugt"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> af <xliff:g id="TOTALRAM">%2$s</xliff:g> blev brugt i de seneste <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> af RAM\'en blev brugt i løbet af <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Baggrund"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Forgrund"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Cachelagret"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Android OS"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Native"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Kerne"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Cacher"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"RAM-brug"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"RAM-brug (baggrund)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Visningstid"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Processer"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Tjenester"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Varighed"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Hukommelsesoplysninger"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 timer"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 timer"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 timer"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 dag"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Vis system"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Skjul system"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Vis procenter"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Brug Uss"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Statistiktype"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Baggrund"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Forgrund"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Cachelagret"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Indtaling og oplæsning"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Indstillinger for indtaling og oplæsning"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Talesøgning"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Android-tastatur"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Indstillinger for indtaling"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Indtaling"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Indtalingstjenester"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Komplet kommandoord og handling"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Enkel oplæsning"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Denne indtalingstjeneste vil kunne foretage lydovervågning, der altid er slået til, og styre taleaktiverede apps på dine vegne. Den kommer fra appen <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Vil du aktivere brugen af denne tjeneste?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Indstillinger for genkendelse på enheden"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Genkendelse på enheden"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Talegenkendelse på enheden"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Foretrukken maskine"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Indstillinger for oplæsningsmaskinen"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Talehastighed og stemmeleje"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Oplæsningsmaskine"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Stemmer"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Talt sprog"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Installer stemmer"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Forsæt til <xliff:g id="TTS_APP_NAME">%s</xliff:g>-appen for at installere stemmer"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Åbn app"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Annuller"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Nulstil"</string>
    <string name="tts_play" msgid="2945513377250757221">"Afspil"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Ikke sikker"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> er ikke sikker"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> er ikke sikker"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Selvjusterende forbindelse"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Forlænger batteritiden og forbedrer enhedens ydeevne ved at administrere din netværksforbindelse automatisk"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Til"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Fra"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Brug Adaptive Connectivity"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Lager for loginoplysninger"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Installer et certifikat"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Ryd loginoplysninger"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Fjern alle certifikater"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Pålidelige loginoplysninger"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Vis pålidelige CA-certifikater"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Loginoplysninger for bruger"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Se og rediger gemte loginoplysninger"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Avanceret"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Loginoplysningerne for denne bruger er ikke tilgængelige"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Installeret til VPN og apps"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Installeret til Wi-Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Installeret til Wi-Fi (i brug)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Vil du fjerne alt indhold?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Lager for loginoplysninger er slettet."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Loginlageret kan ikke ryddes."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Apps med adgang til brugsdata"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA-certifikat"</string>
    <string name="user_certificate" msgid="6897024598058566466">"VPN- og appbrugercertifikat"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Wi‑Fi-certifikat"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Dine data er ikke private"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"CA-certifikater bruges af websites, apps og VPN-netværk til kryptering. Du bør kun installere CA-certifikater fra organisationer, du har tillid til. \n\nHvis du installerer et CA-certifikat, kan certifikatejeren få adgang til dine data, f.eks. adgangskoder eller kreditkortoplysninger fra websites, du besøger, eller apps, du bruger – selv hvis dine data er krypterede."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Installer ikke"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Installer alligevel"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Certifikatet er ikke installeret"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Vil du give "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" tilladelse til at installere certifikater på denne enhed?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Disse certifikater verificerer din identitet ved at dele din enheds unikke id med de apps og webadresser, der er angivet nedenfor"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Tillad ikke"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Tillad"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Se mere"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"App til certifikatadministration"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Ingen"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Certifikater verificerer din identitet, når du bruger de apps og webadresser, der er angivet nedenfor"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Afinstaller certifikater"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Fjern app"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Vil du fjerne denne app?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Denne app vil ikke administrere certifikater, men den forbliver på din enhed. Certifikater, der er installeret af denne app, afinstalleres."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# webadresse}one{# webadresse}other{# webadresser}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Ringesignal i nødsituationer"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Angiv adfærd ved nødopkald"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Sikkerheds­kopiering"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Sikkerhedskopiering og gendannelse"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Personlige oplysninger"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Sikkerhedskopiér data"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Sikkerhedskopiér appdata, Wi-Fi-adgangskoder og andre indstillinger på Googles servere"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Konto til sikkerhedskopiering"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Administrer konto til sikkerhedskopiering"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Inkluder appdata"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Automatisk gendannelse"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Ved geninstallation af en app gendannes sikkerhedskopierede indstillinger og data"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Backuptjenesten er deaktiveret"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Der er ingen konto, der i øjeblikket lagrer sikkerhedskopierede data"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Vil du stoppe sikkerhedskopieringen af dine Wi-Fi-adgangskoder, bogmærker, andre indstillinger og appdata samt slette alle kopier på Googles servere?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Vil du stoppe med at sikkerhedskopiere enhedsdata (f.eks. Wi-Fi-adgangskoder og opkaldshistorik) og appdata (f.eks. indstillinger og filer, som apps har gemt) og slette alle kopier på fjernservere?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Foretag automatisk ekstern sikkerhedskopiering af enhedsdata (f.eks. Wi-Fi-adgangskoder og opkaldshistorik) og appdata (f.eks. indstillinger og filer, der er gemt i apps).\n\n Når du slår automatisk sikkerhedskopiering til, gemmes enheds- og appdata med jævne mellemrum eksternt. Appdata kan være alle former for data, som en app har gemt (afhængigt af udviklerens indstillinger), f.eks. potentielt følsomme data, såsom kontakter, beskeder og billeder."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Indstillinger for enhedsadministrator"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"App til enhedsadministration"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Deaktiver denne app til enhedsadministration"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Afinstaller appen"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Deaktiver og afinstaller"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Apps til enhedsadministration"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Der er ikke nogen tilgængelige apps til enhedsadministration"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Der er ingen tilgængelige trust agents"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Aktivér appen til enheds­administration?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktivér denne app til enhedsadministration"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Enhedsadministrator"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Hvis denne administratorapp aktiveres, får appen <xliff:g id="APP_NAME">%1$s</xliff:g> tilladelse til at foretage følgende handlinger:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Denne enhed administreres og overvåges af <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Denne administratorapp er aktiv og giver appen <xliff:g id="APP_NAME">%1$s</xliff:g> tilladelse til at udføre følgende handlinger:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Vil du aktivere Profiladministrator?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Vil du tillade overvågning?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Hvis du fortsætter, administreres din bruger af din administrator, som også kan gemme tilknyttede data ud over dine personlige data.\n\nDin administrator kan overvåge og administrere indstillinger, adgang, apps og data, der er knyttet til denne bruger, herunder netværksaktivitet og din enheds lokationsoplysninger."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Andre valgmuligheder er deaktiveret af din administrator"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Få flere oplysninger"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Notifikationslogfil"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Notifikationshistorik"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Sidste %d timer"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Udsat"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Afvist for nylig"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# notifikation}one{# notifikation}other{# notifikationer}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Ringetone og vibration ved opkald"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Netværksoplysninger"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Synkronisering aktiveret"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sync deaktiveret"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Synkroniserer nu"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Synkroniseringsfejl."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Synkroniseringen mislykkedes"</string>
    <string name="sync_active" msgid="5787407579281739975">"Synkronisering er aktiveret"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Synkronisering"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Der er i øjeblikket problemer med synkroniseringen. Den etableres igen om lidt."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Tilføj konto"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Arbejdsprofilen er endnu ikke tilgængelig"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Arbejdsapps"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Fjern arbejdsprofil"</string>
    <string name="background_data" msgid="321903213000101158">"Baggrundsdata"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Apps kan altid synkronisere, sende og modtage data"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Deaktiver baggrundsdata?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Deaktivering af baggrundsdata forlænger batteriets levetid og reducerer dataforbruget. Nogle apps kan muligvis stadig bruge dataforbindelsen i baggrunden."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Synkronisering til"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Synkronisering slået fra"</string>
    <string name="sync_error" msgid="846923369794727644">"Synkroniseringsfejl"</string>
    <string name="last_synced" msgid="1527008461298110443">"Sidst synkroniseret <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Synkroniserer nu…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Indstillinger for sikkerhedskopiering"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Sikkerhedskopier mine indstillinger"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Synkroniser nu"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Annuller synkronisering"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Tryk for at synkronisere nu <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">"Kalender"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Kontakter"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Indstillinger for synkronisering af app"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Data og synkronisering"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Skift adgangskode"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Indstillinger for konto"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Fjern konto"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Tilføj en konto"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Vil du fjerne kontoen?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Din administrator har ikke givet tilladelse til at foretage denne ændring"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Der kan ikke synkroniseres manuelt"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Synkronisering af dette element er deaktiveret lige nu. Hvis du vil ændre indstillingen, skal du aktivere baggrundsdata og automatisk synkronisering midlertidigt."</string>
    <string name="delete" msgid="8330605554706263775">"Slet"</string>
    <string name="select_all" msgid="7898929601615536401">"Markér alle"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Dataforbrug"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobildata og Wi‑Fi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Automatisk synk. af persondata"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Synkroniser arbejdsdata automatisk"</string>
    <string name="account_settings_menu_auto_sync_private" msgid="2315144351530596228">"Automatisk synkronisering af private data"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Skift cyklus..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Dag i måneden, hvor cyklus for dataforbrug skal nulstilles"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Ingen apps har brugt data i denne periode."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Forgrund"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Baggrund"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"begrænset"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Vil du deaktivere mobildata?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Angiv mobildatagrænse"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Angiv grænse for 4G-data"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Angiv grænse for 2G-3G-data"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Angiv grænse for Wi-Fi-data"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi-Fi"</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">"Intet"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobildata"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"2G-3G-data"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"4G-data"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Forgrund:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Baggrund:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Indstillinger for app"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Baggrundsdata"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Aktivér brug af mobildata i baggrunden"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Hvis du vil begrænse baggrundsdata for denne app, skal du først angive en mobildatagrænse."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Vil du begrænse baggrundsdata?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Denne funktion kan medføre, at en app, der er afhængig af baggrundsdata, ikke længere fungerer, når der kun er mobilnetværk til rådighed.\n\nDu kan finde mere hensigtsmæssige metoder til kontrol af dataforbruget i de indstillinger, der er tilgængelige i selve appen."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Begrænsning af baggrundsdata er kun mulig, hvis du har angivet en grænse for mobildata."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Aktivér automatisk datasynk.?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Deaktiver automatisk datasynk.?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Dette vil sænke data- og batteriforbruget, men du skal til gengæld synkronisere hver konto manuelt for at hente de seneste oplysninger, og du vil ikke modtage notifikationer, når der kommer nye opdateringer."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Dato for nulstilling af forbrugsperiode"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Dato i hver måned:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Angiv"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Konfigurer en advarsel om dataforbrug"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Angiv en grænse for dataforbrug"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Grænse for dataforbrug"</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">"advarsel"</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">"grænse"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Fjernede apps"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Fjernede apps og brugere"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Netværksbrug"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Forbrugsafregnet"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Navn"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Type"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Serveradresse"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"IPSec-identifikator"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"IPsec-forhåndsdelt nøglekodning"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"IPSec-brugercertifikat"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"IPSec CA-certifikat"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"IPSec-servercertifikat"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Vis avancerede valgmuligheder"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Brugernavn"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Adgangskode"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Gem kontooplysninger"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(bruges ikke)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(ingen verificering af serveren)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(modtaget fra serveren)"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"De indtastede oplysninger understøtter ikke konstant VPN"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Annuller"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Annuller"</string>
    <string name="vpn_save" msgid="683868204634860888">"Gem"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Tilslut"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Erstat"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Rediger VPN-profil"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Glem"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Opret forbindelse til <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Vil du afbryde dette VPN?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Afbryd forbindelse"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Version"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Glem VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Erstat det eksisterende VPN-netværk?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Vil du konfigurere konstant VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Når denne indstilling er slået til, vil du ikke have internetforbindelse, før VPN-netværket etablerer forbindelse"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Dit eksisterende VPN-netværk erstattes, og du vil ikke have internetforbindelse, før VPN-netværket etablerer forbindelse"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Du har allerede forbindelse til et konstant VPN-netværk. Hvis du opretter forbindelse til et andet netværk, erstattes dit eksisterende VPN, og Altid aktiveret-tilstanden deaktiveres."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Du har allerede forbindelse til et VPN-netværk. Hvis du opretter forbindelse til et andet, erstattes dit eksisterende VPN."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Aktivér"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> kan ikke oprette forbindelse"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Denne app understøtter ikke konstant VPN"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Tilføj VPN-profil"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Rediger profil"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Slet profil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Konstant VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Der er ikke tilføjet nogen VPN-netværk"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Vær forbundet til VPN hele tiden"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Understøttes ikke af denne app"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Altid slået til"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Ikke sikker"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Bloker forbindelser uden VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Vil du kræve VPN-forbindelse?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Ikke sikkert. Opdater til et IKEv2 VPN-netværk"</string>
    <string name="vpn_start_unsupported" msgid="7139925503292269904">"Den ikke-understøttede VPN kunne ikke startes."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Vælg en VPN-profil, der altid skal være forbindelse til. Netværkstrafik tillades kun, når der er forbindelse til dette VPN-netværk."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Ingen"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Et konstant VPN kræver en IP-adresse til både server og DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Der er ingen netværksforbindelse. Prøv igen senere."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Frakoblet VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Ingen"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Der mangler et certifikat. Prøv at redigere profilen."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"System"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Bruger"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Deaktiver"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Aktivér"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Afinstaller"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Angiv som pålidelig"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Vil du aktivere systemets CA-certifikat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Vil du deaktivere systemets CA-certifikat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Vil du fjerne bruger-CA-certifikatet?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Anvendes i øjeblikket af"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Denne post indeholder"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 brugernøgle"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 brugercertifikat"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 CA-certifikat"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA-certifikater"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Loginoplysninger"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Fjernede loginoplysninger: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Der er ikke installeret nogen brugerloginoplysninger"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Stavekontrol"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Stavekontrol til arbejdsprofil"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Angiv din aktuelle adgangskode til fuldstændig sikkerhedskopiering:"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Angiv din nye adgangskode til fuldstændig sikkerhedskopiering:"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Gentag din nye adgangskode til fuldstændig sikkerhedskopiering:"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Angiv adgangskode til sikkerhedskopi"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Annuller"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Yderligere systemopdateringer"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Netværket kan være overvåget"</string>
    <string name="done_button" msgid="6269449526248267">"Luk"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Tillad eller fjern certifikat}one{Tillad eller fjern certifikat}other{Tillad eller fjern certifikater}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} har installeret en certifikatautoritet på din enhed, hvilket giver vedkommende mulighed for at overvåge netværksaktivitet på din enhed, herunder mails, apps og sikre websites.\n\nKontakt din administrator for at få flere oplysninger om dette certifikat.}one{{orgName} har installeret en certifikatautoritet på din enhed, hvilket giver vedkommende mulighed for at overvåge netværksaktivitet på din enhed, herunder mails, apps og sikre websites.\n\nKontakt din administrator for at få flere oplysninger om dette certifikat.}other{{orgName} har installeret certifikatautoriteter på din enhed, hvilket giver vedkommende mulighed for at overvåge netværksaktivitet på din enhed, herunder mails, apps og sikre websites.\n\nKontakt din administrator for at få flere oplysninger om disse certifikater.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} har installeret en certifikatautoritet for din arbejdsprofil, hvilket giver vedkommende mulighed for at overvåge aktivitet på dit arbejdsnetværk, herunder mails, apps og sikre websites.\n\nKontakt din administrator for at få flere oplysninger om dette certifikat.}one{{orgName} har installeret en certifikatautoritet for din arbejdsprofil, hvilket giver vedkommende mulighed for at overvåge aktivitet på dit arbejdsnetværk, herunder mails, apps og sikre websites.\n\nKontakt din administrator for at få flere oplysninger om dette certifikat.}other{{orgName} har installeret certifikatautoriteter for din arbejdsprofil, hvilket giver vedkommende mulighed for at overvåge aktivitet på dit arbejdsnetværk, herunder mails, apps og sikre websites\n\nKontakt din administrator for at få flere oplysninger om disse certifikater.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"En tredjepart kan overvåge din netværksaktivitet, herunder mails, apps og sikre websites.\n\nPålidelige loginoplysninger, der er installeret på din enhed, gør dette muligt."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Tjek certifikatet}one{Tjek certifikatet}other{Tjek certifikaterne}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Flere brugere"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Brugere og profiler"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Tilføj bruger eller profil"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Begrænset profil"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Ikke konfigureret"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Ikke oprettet – begrænset profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Ikke konfigureret – Arbejdsprofil"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administrator"</string>
    <string name="user_you" msgid="3070562015202859996">"Dig (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Du kan ikke tilføje flere brugere. Fjern en bruger for at tilføje en ny."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Begrænsede profiler kan ikke tilføje konti"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Slet <xliff:g id="USER_NAME">%1$s</xliff:g> fra denne enhed"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Lås skærmindstillinger"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Tilføj brugere fra låseskærm"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Skift til administrator, når sat i dockingstation"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Vil du slette dig selv?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Vil du slette brugeren?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Vil du fjerne profilen?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Fjern arbejdsprofilen?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Alle apps og data slettes."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Alle apps og data i denne profil slettes, hvis du fortsætter."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Alle apps og data slettes."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Tilføjer ny bruger..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Slet bruger"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Slet"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Alle apps og data i denne session slettes."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Fjern"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Gæst (dig)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Brugere"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Andre brugere"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Slet gæsteaktivitet"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Slet alle gæsteapps og -data ved afslutning af gæstetilstand"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Vil du slette gæsteaktiviteten?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Apps og data fra denne gæstesession slettes nu, og al fremtidig gæsteaktivitet slettes, hver gang du afslutter gæstetilstand"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"slet, gæst, aktivitet, fjern, data, besøgende, ryd"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"Tillad, at gæsten foretager telefonopkald"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Opkaldshistorikken deles med gæstebrugeren"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Aktivér telefonopkald og sms"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Tildel denne bruger administratorrettigheder"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Slet bruger"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Vil du aktivere telefonopkald og sms?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Opkalds- og sms-historikken vil blive delt med denne bruger."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Vil du fjerne administratorrettighederne?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Hvis du fjerner administratorrettigheder for denne bruger, kan du eller en anden administrator tildele dem igen senere."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Nødoplysninger"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Oplysninger og kontakter for <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Åbn <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Tillad apps og indhold"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Applikationer med begrænsninger"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Udvid indstillingerne for applikationen"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Vælg de apps, der skal installeres"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Installer tilgængelige apps"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Kontaktløse betalinger"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Standardapp til betaling"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Du kan betale med en betalingsapp ved at holde bagsiden af din enhed op mod en betalingsterminal"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Få flere oplysninger"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Angiv arbejdsapp som standardapp til betaling?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Sådan betaler du med en arbejdsapp:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"Arbejdsprofilen skal være aktiveret."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"Du skal angive pinkoden, mønsteret eller adgangskoden til din arbejdskonto."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Sådan fungerer det"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Betal med din telefon i butikker"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Standardapp til betaling"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Ikke angivet"</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">"Brug standardappen til betaling"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Brug standardappen til betaling"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Altid"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Undtagen når en anden betalingsapp er åben"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Ved kontaktløse terminaler vil du betale med:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Betaling på terminalen"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Konfigurer en betalingsapp. Derefter skal du blot holde bagsiden af din telefon mod en terminal med symbolet for kontaktløs betaling."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"OK, det er forstået"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Mere…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Angiv en standardapp til betalinger"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Opdater standardappen til betalinger"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Ved kontaktløse terminaler vil du betale med <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Ved kontaktløse terminaler vil du betale med <xliff:g id="APP_0">%1$s</xliff:g>.\n\nDenne app erstatter <xliff:g id="APP_1">%2$s</xliff:g> som standardapp til betalinger."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Angiv standardindstilling"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Opdater"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Arbejde"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Begrænsninger"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Fjern begrænsninger"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Skift pinkode"</string>
    <string name="help_label" msgid="2896538416436125883">"Hjælp og feedback"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Konto til indhold"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"Foto-id"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Ekstreme trusler"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Få advarsler ved ekstreme trusler mod liv og ejendom"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Alvorlige trusler"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Få advarsler ved alvorlige trusler mod liv og ejendom"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"GULE underretninger"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Modtag bulletiner om kidnapning af børn"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Gentag"</string>
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Mobilbaseret varsling"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Netværksudbydere"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Adgangspunkter (APN)"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Avancerede opkald"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"4G-opkald"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Anvend LTE-tjenester til at forbedre taleopkald (anbefalet)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Anvend 4G-tjenester til at forbedre taleopkald (anbefalet)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Brug 5G til taleopkald"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Send kontakter til dit mobilselskab"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Send dine kontakters telefonnumre for at aktivere udvidede funktioner"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Vil du sende dine kontakter til <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Vil du sende dine kontakter til dit mobilselskab?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Dine kontakters telefonnumre sendes jævnligt til <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Disse oplysninger indikerer, om dine kontakter kan bruge bestemte funktioner som f.eks. videoopkald eller visse beskedfunktioner."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Dine kontakters telefonnumre sendes jævnligt til dit mobilselskab.<xliff:g id="EMPTY_LINE">

</xliff:g>Disse oplysninger indikerer, om dine kontakter kan bruge bestemte funktioner som f.eks. videoopkald eller visse beskedfunktioner."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Foretrukken netværkstype"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (anbefales)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"MMS-beskeder"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Send og modtag, når mobildata er slået fra"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Skift automatisk mobildata"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Brug dette netværk, når det har bedre dækning"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"SIM-kort til arbejde"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Adgang til apps og indhold"</string>
    <string name="user_rename" msgid="8735940847878484249">"OMDØB"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Angiv begrænsninger for appen"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Kontrolleret af <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Denne app kan få adgang til dine konti"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Denne app har adgang til dine konti. Administreres af <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Wi-Fi og mobil"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Tillad ændring af Wi-Fi- og mobilindstillinger"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Tillad ændring af Bluetooth-parringer og -indstillinger"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Lokation"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Tillad, at apps bruger dine lokationsoplysninger"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Tilbage"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Næste"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Formatér på en anden måde"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"SIM-kort"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Mobildata er ikke tilgængelig"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Tryk for at vælge et data-SIM-kort"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Brug altid denne indstilling til opkald"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Vælg SIM-kort til mobildata"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Vælg et SIM-kort til sms"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Data-SIM skiftes. Dette kan tage op til et minut…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Vil du bruge <xliff:g id="NEW_SIM">%1$s</xliff:g> til mobildata?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Hvis du skifter til <xliff:g id="NEW_SIM">%1$s</xliff:g>, anvendes <xliff:g id="OLD_SIM">%2$s</xliff:g> ikke længere til mobildata."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Brug <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Ring med"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Angiv SIM-kortnavn"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"SIM-kortrille %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Orange"</string>
    <string name="color_purple" msgid="6603701972079904843">"Lilla"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"SIM-status"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"SIM-status (SIM-kortrille %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">"Der blev skiftet SIM-kort."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Tryk for at konfigurere"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Spørg hver gang"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Du har ikke valgt endnu"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Valg af SIM-kort"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Indstillinger"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Netværk og internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobildata, Wi‑Fi, hotspot"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi-Fi, hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Forbundne enheder"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, parring"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, køretilstand, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, køretilstand"</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, køretilstand, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, køretilstand"</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">"Ikke tilgængelig, fordi NFC er slået fra"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Du skal først installere en app til betalinger"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Seneste apps, standardapps"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Apps i arbejdsprofilen har ikke adgang til notifikationsindstillingerne."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Adgangskoder og konti"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Gemte adgangskoder, autofyld, synkroniserede konti"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Standardapps"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Klonede apps"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Opret en anden forekomst af appen, så du kan bruge to konti på samme tid."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Apps, der kan klones."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"<xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g> er klonet, <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g> kan klones"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Slet alle appkloner"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Sletningen af alle appkloner mislykkedes"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Opretter…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Klonet"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Opretter en klon af <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"En klon af <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> blev oprettet"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Sprog, bevægelser, klokkeslæt, sikkerhedskopiering"</string>
    <string name="languages_setting_summary" msgid="2650807397396180351">"Systemsprog, appsprog, regionsindstillinger, tale"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, netværksforbindelse, internet, trådløs, data, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Wi‑Fi-notifikation, wifi-notifikation"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"dataforbrug"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Brug 24-timersformat"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Åbn med"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Apps"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"tidszone"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Chathoved, system, underretning, vindue, dialogboks, skærm, oven på andre apps, tegn"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Lommelygte, lys, lygte"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, skift, styring"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobil, mobilselskab, trådløs, data, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, ring op, opkald"</string>
    <string name="keywords_display" msgid="874738809280751745">"skærm, touchskærm"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"nedtone skærm, touchskærm, batteri, lys"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"dæmpe skærm, aften, nat, farvetone, night shift, lysstyrke, skærmfarve, farve"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"baggrund, tilpas, tilpas skærm"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"tekststørrelse"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projektér, cast, spejling af skærm, skærmdeling, spejling, del skærm, cast skærm"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"plads, disk, harddisk, enhedsbrug"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"strømforbrug, opladning"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"se batteriforbrug, batteriforbrug, strømforbrug"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"batterisparefunktion, strømsparefunktion, sparefunktion"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"adaptive præferencer, batterijustering"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"stavning, ordbog, stavekontrol, autokorrektur"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"genkender, indtaling, tale, tal, sprog, håndfri, frie hænder, genkendelse, stødende, ord, lyd, historik, bluetooth, headset"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"hastighed, sprog, standard, tale, indtaling, tts, hjælpefunktion, skærmlæser, blind"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"ur, militærtid"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"nulstil, gendan, fabriksdata"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"rydde, slette, gendanne, rydde, nulstille, gendanne fabriksindstillinger"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"printer"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"højttalerbip, højttaler, lydstyrke, slå lyden fra, lydløs, lyd, musik, haptisk, berøring, vibration, vibrer"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"forstyr ikke, afbryd, afbrydelse, pause"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"tæt på, lokation, historik, rapportering, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"konto, tilføj en konto, arbejdsprofil, tilføj konto, fjern, slet"</string>
    <string name="keywords_users" msgid="3497517660077620843">"begrænsning, begræns, begrænset"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"rettelser, ret, lyd, vibrer, automatisk, sprog, bevægelse, anbefale, forslag, tema, stødende, ord, type, emoji, international"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"nulstilling, præferencer, standard"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"apps, download, apps, system"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"apps, tilladelser, sikkerhed"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"apps, standard"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorer optimeringer, hvil, app-standby"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"farverig, RGB, sRGB, farve, naturlig, standard"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, opløsning, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"farve, temperatur, D65, D73, hvid, gul, blå, varm, kølig"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"stryg for at låse op, adgangskode, mønster, pinkode"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"skærmfastholdelse"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"arbejdsudfordring, arbejde, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"arbejdsprofil, administreret profil, samle, samling, arbejde, profil"</string>
    <string name="keywords_fold_lock_behavior" msgid="6278990772113341581">"aktiv, dvale, lås ikke, forbliv oplåst i foldet tilstand, foldet, folde, lukke, fold, luk, deaktiver skærm"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"bevægelser"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"Wallet"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"betal, tryk, betalinger"</string>
    <string name="keywords_backup" msgid="707735920706667685">"sikkerhedskopiering, sikkerhedskopiér"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"ansigt, oplåsning, godkendelse, log ind"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"ansigt, lås op, ansigtsoplåsning, godkendelse, log ind, fingeraftryk, biometri, biometrisk"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, prl version, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"netværk, mobilnetværkstilstand, tjenestetilstand, signalstyrke, type mobilnetværk, roaming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"netværk, mobilnetværkstilstand, tjenestetilstand, signalstyrke, mobilnetværkstype, roaming, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"netværk, mobilnetværkstilstand, tjenestetilstand, signalstyrke, type mobilnetværk, roaming, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"netværk, mobilnetværkstilstand, tjenestetilstand, signalstyrke, mobilnetværkstype, roaming, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"EID"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"serienummer, hardwareversion"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"batterioplysninger, produktionsdato, antal cyklusser, ibrugtagning"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"seneste sikkerhedsopdatering i Android, basebandversion, kernesystem"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"tema, lyst, mørkt, tilstand, lysfølsomhed, fotofobi, gør mørkere, mørkere, mørk tilstand, migræne"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"mørkt tema"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"fejl"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Aktiv låseskærm, visning af låseskærm"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"notifikation på låseskærm, notifikationer"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"ansigt"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"fingeraftryk, tilføj fingeraftryk"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"ansigt, fingeraftryk, tilføj fingeraftryk"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"uroplåsning, tilføj uroplåsning"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"dæmp skærmlys, touchskærm, batteri, intelligent lysstyrke, dynamisk klarhed, automatisk lysstyrke"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"smart, dæmp skærm, dvale, batteri, timeout, opmærksom skærm, visning, display, inaktivitet"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"kamera, smart, roter automatisk, automatisk rotation, roter, vend, rotation, stående, liggende, format, retning, landskab, portræt, lodret, vandret"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"opgradere, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"forstyr ikke, planlægge, notifikationer, blokere, lydløs, vibrere, sove, arbejde, fokusere, lyd, slå lyden fra, dag, hverdag, weekend, hverdagsaften, begivenhed"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"skærm, låsetid, timeout, låseskærm"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"hukommelse, cache, data, slet, ryd, frigør, plads"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"forbundet, enhed, høretelefoner, headset, højttaler, trådløs, parre, øretelefoner, musik, medier"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"baggrund, tema, gitter, tilpas, tilpasning"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"ikon, kontrastfarve, farve, startskærm, låseskærm, genvej, urets størrelse"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"standard, assistent"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"betaling, standard"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"ny notifikation"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"usb-netdeling, bluetooth-netdeling, wi-fi-hotspot"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"berøringssensorer, vibrer, vibration"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"berøring, vibrere, skærm, følsomhed"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"berøringssensorer, vibration, telefon, opkald, følsomhed, ringetone"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"berøring, vibration, telefon, opkald, ringetone, gradvis"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"berøring, vibration, følsomhed, notifikation"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"berøring, vibration, følsomhed, alarm"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"berøring, vibration, følsomhed, medier"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"berøringssensorer, vibrer, vibration"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"batterisparefunktion, klæbende, vedvare, strømbesparelse, batteri"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutine, tidsplan, batterisparefunktion, strømsparefunktion, batteri, automatisk, procent"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, avancerede opkald, 4g-opkald"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, avancerede opkald, 5g-opkald"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"tilføj sprog, tilføj et sprog"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"tekststørrelse, stor skrifttype, store bogstaver, stor skrifttype, stor tekst, nedsat syn, gør teksten større, større skrifttype, forstørrelse af skrifttype"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"altid tændt pauseskærm, AOD (always on ambient display)"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, tag, læser"</string>
    <string name="keywords_keyboard_vibration" msgid="6485149510591654697">"tastatur, haptisk teknologi, vibration"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Lydstyrke, vibration, Forstyr ikke"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Lydstyrke for medier"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Lydstyrke for castet indhold"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Lydstyrke for opkald"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Lydstyrke for alarmer"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Lydstyrke for ringetone og notifikationer"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Lydstyrke for ringetone"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Lydstyrke for notifikationer"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Ringesignalet er indstillet til lydløs"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Ringesignalet er indstillet til vibration"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Notifikationer er indstillet til lydløs, enheden vibrerer ved notifikationer"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"<xliff:g id="VOLUME_TYPE">%1$s</xliff:g> er indstillet til lydløs"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Ikke tilgængelig, fordi ringetonen er slået fra"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Ringetone ved opkald"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Standardlyd for notifikationer"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Lyd fra appen"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Standardlyd for notifikationer"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Standardlyd for alarmer"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Vibrer først, og ring så gradvist højere"</string>
    <string name="spatial_audio_title" msgid="1775370104206884711">"Rumlig lyd"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Toner for tastatur"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Lyd ved skærmlåsning"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Lyd og vibration ved opladning"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Lyde for dockingstation"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Lyd ved berøring"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Vis altid ikonet, når vibration er aktiveret"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Dockhøjttaler afspiller"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Al lyd"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Kun medielyd"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Stilhed"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Toner"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibrationer"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Aktivér lyde"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Livetekstning"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Undertekster til medier"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Høretelefoner med ledning"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Lyden fra kompatible medieenheder bliver endnu bedre"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Fra"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Til/<xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Til/<xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> og <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Du kan også aktivere rumlig lyd for Bluetooth-enheder."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Indstillinger for forbundne enheder"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Ingen}=1{1 tidsplan er angivet}one{# tidsplan er angivet}other{# tidsplaner er angivet}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Forstyr ikke"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Få kun notifikationer fra vigtige personer og apps"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Begræns antallet af afbrydelser"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Aktivér Forstyr ikke"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Alarmer og medielyde kan afbryde"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Tidsplaner"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Slet tidsplaner"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Slet"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Rediger"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Tidsplaner"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Tidsplan"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Planlæg"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Gør telefonen lydløs på bestemte tidspunkter"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Angiv regler for Forstyr ikke"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Planlæg"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Anvend tidsplan"</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">"Tillad afbrydelser, der laver lyd"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Bloker visuelle forstyrrelser"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Tillad visuelle signaler"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Visningsindstillinger for skjulte notifikationer"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Når Forstyr ikke er aktiveret"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Ingen lyd fra notifikationer"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Notifikationer vises på skærmen"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Din telefon vil ikke afspille lyd eller vibrere, når du får notifikationer."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Ingen lyd eller visuelle signaler fra notifikationer"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Notifikationer kan ikke ses eller høres"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Din telefon viser ikke nye eller eksisterende notifikationer, og den vibrerer eller ringer heller ikke i forbindelse med disse. Husk, at vigtige notifikationer om enhedsaktivitet og -status stadig vises.\n\nNår du deaktiverer Forstyr ikke, kan du finde ulæste notifikationer ved at stryge nedad fra toppen af skærmen."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Tilpasset"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Aktivér tilpasset indstilling"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Fjern tilpasset indstilling"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Ingen lyd fra notifikationer"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Delvist skjult"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Ingen lyd eller visuelle signaler fra notifikationer"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Tilpassede begrænsninger"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Når skærmen er tændt"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Når skærmen er slukket"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Slå lyd og vibration fra"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Aktivér ikke skærmen"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Undlad at bruge blinkende lys"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Undlad at vise notifikationer på skærmen"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Skjul statusbjælkeikoner øverst på skærmen"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Skjul notifikationsprikker på appikoner"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Væk ikke ved notifikationer"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Skjul i panelet, der trækkes ned"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Aldrig"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Når skærmen er slukket"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Når skærmen er tændt"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Lyd og vibration"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Lyd, vibration og visse visuelle tegn på notifikationer"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Lyd, vibration og visuelle tegn på notifikationer"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Notifikationer om grundlæggende enhedsaktivitet og -status skjules aldrig."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Ingen"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"andre valgmuligheder"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Tilføj"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Aktivér"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Aktivér nu"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Deaktiver nu"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Forstyr ikke er aktiveret indtil <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Forstyr ikke forbliver aktiveret, indtil du deaktiverer tilstanden"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Forstyr ikke blev automatisk aktiveret af en tidsplan (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Forstyr ikke blev automatisk aktiveret af en app <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Forstyr ikke er aktiveret for <xliff:g id="RULE_NAMES">%s</xliff:g> med tilpassede indstillinger."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Se tilpassede indstillinger"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Kun prioritet"</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">"Til – <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Til"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Spørg hver gang"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Indtil du deaktiverer"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 time}one{# time}other{# timer}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minut}one{# minut}other{# minutter}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Fra}=1{Fra – 1 tidsplan kan starte automatisk}one{Fra – # tidsplan kan starte automatisk}other{Fra – # tidsplaner kan starte automatisk}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Hvad kan afbryde Forstyr ikke"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Personer"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Apps"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarmer og andre afbrydelser"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Tidsplaner"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Varighed af Kvikmenu"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Generelt"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Når Forstyr ikke er aktiveret, er der kun lyd eller vibration ved de elementer, du tillader ovenfor."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Tilpassede indstillinger"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Gennemgå tidsplan"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"OK"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Notifikationer"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Varighed"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Beskeder, begivenheder og påmindelser"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Når Forstyr ikke er aktiveret, slås lyden fra for beskeder, påmindelser og begivenheder med undtagelse af de elementer, du tillader ovenfor. Du kan ændre beskedindstillingerne, så dine venner, din familie eller andre kontakter kan få fat i dig."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Udfør"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Indstillinger"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Ingen lyd eller visuelle signaler fra notifikationer"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Ingen lyd fra notifikationer"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Notifikationer kan ikke ses eller høres. Opkald fra stjernemarkerede kontakter og gentagne opkald er tilladt."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(aktuel indstilling)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Vil du ændre notifikationsindstillingerne for Forstyr ikke?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Lyde for arbejdsprofil"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Brug lyde fra din personlige profil"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Brug de samme lyde som på din personlige profil"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Ringetone til arbejdstelefon"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Standardlyd for arbejdsnotifikationer"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Standardlyd for arbejdsalarmer"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Samme som din private profil"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Vil du bruge lydene fra din personlige profil?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Bekræft"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Din arbejdsprofil bruger de samme lyde som din personlige profil"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Notifikationer"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Notifikationshistorik, samtaler"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Samtale"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Administrer"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Appnotifikationer"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Styr notifikationer fra individuelle apps"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Generelt"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Arbejdsunderretninger"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Arbejdsprofil"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Automatisk prioritetsniveau for notifikationer"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Angiv automatisk notifikationer med lavere prioritet som Diskret"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Automatisk rangering af notifikationer"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Ranger automatisk notifikationer efter relevans"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Feedback om tilpassede notifikationer"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Vis justeringer af notifikationer, og vis en mulighed for at give feedback til systemet"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Nulstil vigtigheden af notifikationer"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Nulstil brugerangivne indstillinger for vigtighed, og tillad, at notifikationsassistenten prioriterer."</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Foreslåede handlinger og svar"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Vis automatisk foreslåede handlinger og svar"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Vis seneste notifikationer og notifikationer, der er udsat"</string>
    <string name="notification_history" msgid="8663811361243456201">"Notifikationshistorik"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Brug notifikationshistorik"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Notifikationshistorikken er deaktiveret"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Aktivér notifikationshistorikken for at se de seneste notifikationer og notifikationer, der er udsat"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Der er ingen nye notifikationer"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Nye og udsatte notifikationer vises her"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"se indstillinger for notifikationer"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"åbn notifikationen"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Tillad udsættelse af notifikationer"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Notifikationsprik på appikon"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Bobler"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Bobler"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Lav denne samtale til en boble"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Vis flydende ikon oven på apps"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Vil du aktivere bobler på enheden?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Hvis du aktiverer bobler for denne app, aktiveres funktionen overalt på din enhed.\n\nDette påvirker andre apps og samtaler, som kan vises i bobler."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Aktivér"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Luk"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Til – Samtaler kan vises som svævende ikoner"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Tillad, at apps viser bobler"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Nogle samtaler vises som svævende ikoner oven på andre apps"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Alle samtaler kan vises i bobler"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"De valgte samtaler kan vises i bobler"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Intet kan vises i bobler"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Samtaler"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Alle samtaler kan vises i bobler undtagen"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Deaktiver bobler for denne samtale"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Aktivér bobler for denne samtale"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Stryg til højre for at afvise og til venstre for at se menuen"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Stryg til venstre for at afvise og til højre for at se menuen"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Skjul lydløse notifikationer på statusbjælken"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Blinkende lys"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privatliv"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Spring låseskærmen over"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Gå direkte til den seneste skærm efter oplåsning. Notifikationer vises ikke på låseskærmen. Stryg nedad fra toppen for at se dem."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Låseskærm, lås skærm, spring over, tilsidesæt"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Når arbejdsprofilen er låst"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Vis kun nye notifikationer på låseskærmen"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Fjern automatisk tidligere sete notifikationer fra låseskærmen"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Notifikationer på låseskærmen"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Vis samtaler, standard og lydløs"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Vis samtaler, standard og lydløs"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Skjul lydløse samtaler og notifikationer"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Vis ingen notifikationer"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Notifikationer om følsomme oplysninger"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Vis følsomme oplysninger, når enheden er låst"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Notifikationer for følsomme oplysninger på arbejdsprofil"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Vis følsomme oplysninger fra arbejdsprofilen, når enheden er låst"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Vis alt indhold i notifikationer"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Vis kun følsomt indhold, når skærmen er låst op"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Vis slet ingen notifikationer"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6326229471276829730">"Hvad skal der vises på låseskærmen?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Låseskærm"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Vis alt indhold i arbejdsnotifikationer"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Skjul følsomt arbejdsindhold"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Hvordan skal profilunderretninger vises, når din enhed er låst?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Profilunderretninger"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Notifikationer"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Appnotifikationer"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Notifikationskategori"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Adfærd"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Samtaler"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Samtalesektion"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Giv appen tilladelse til bruge samtalesektionen"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Ikke en samtale"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Fjern fra samtalesektionen"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Dette er en samtale"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Føj til samtalesektionen"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Ingen prioriterede samtaler"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# prioriteret samtale}one{# prioriteret samtale}other{# prioriterede samtaler}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Prioriterede samtaler"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Vis øverst i samtalesektionen som svævende bobler"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Vises øverst i samtalesektionen"</string>
    <string name="other_conversations" msgid="551178916855139870">"Ikke-prioriterede samtaler"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Samtaler, du har ændret"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Seneste samtaler"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Ryd seneste samtaler"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"De seneste samtaler blev fjernet"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Samtalen blev fjernet"</string>
    <string name="clear" msgid="5092178335409471100">"Ryd"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Prioriterede og ændrede samtaler vises her"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Hvis du markerer en samtale som prioriteret eller foretager andre ændringer af samtaler, vises de her. \n\nSådan ændrer du samtaleindstillinger: \nStryg ned fra toppen af skærmen for at åbne rullepanelet, og hold derefter en samtale nede."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimer"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Pop op-visning"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Lydløs"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Standard"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Tillad afbrydelser"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Lad appen give lyd, vibrere og/eller vise notifikationer på skærmen"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritet"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Vises øverst i samtalesektionen som en svævende boble og med profilbillede på låseskærmen"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"De fleste samtalefunktioner understøttes ikke af <xliff:g id="APP_NAME">%1$s</xliff:g>. Du kan ikke angive en samtale som prioriteret, og samtaler vises ikke som svævende bobler."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Begræns notifikationer til én linje i notifikationspanelet"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Ingen lyd eller vibration"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Ingen lyd eller vibration, og den vises længere nede i samtalesektionen"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Kan ringe eller vibrere baseret på enhedens indstillinger"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Når enheden er låst op, vises notifikationer som et banner øverst på skærmen"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Alle notifikationer fra \"<xliff:g id="APP_NAME">%1$s</xliff:g>\""</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Alle notifikationer for <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Ca. # notifikation om dagen}one{Ca. # notifikation om dagen}other{Ca. # notifikationer om dagen}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Ca. # notifikation om ugen}one{Ca. # notifikation om ugen}other{Ca. # notifikationer om ugen}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Aldrig"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Enheds- og appnotifikationer"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Styr, hvilke apps og enheder der må læse notifikationer"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Adgangen til notifikationer fra arbejdsprofilen er blokeret"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Forbedrede notifikationer"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Få forslag til handlinger, svar og meget mere"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Ingen"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Ingen installerede apps har anmodet om adgang til notifikationer."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Giv adgang til notifikationer"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Tilpassede Android-notifikationer blev erstattet af forbedrede notifikationer i Android 12. Denne funktion viser foreslåede handlinger og svar og organiserer dine notifikationer. \n\nForbedrede notifikationer kan få adgang til indhold i notifikationer, bl.a. personlige oplysninger som f.eks. beskeder og navne på kontakter. Funktionen kan også afvise eller svare på notifikationer, f.eks. ved at besvare telefonopkald og justere Forstyr ikke."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Tillad adgang til notifikationer for <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"Appen <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> vil kunne læse alle notifikationer, herunder personlige oplysninger såsom navne på kontakter, billeder og teksten i de beskeder, du modtager. Appen vil også kunne udsætte eller afvise notifikationer eller aktivere knapper i notifikationer, herunder besvare telefonopkald. \n\nHerudover vil appen få mulighed for at aktivere eller deaktivere Forstyr ikke og ændre relaterede indstillinger."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Appen <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> vil kunne:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Læse dine notifikationer"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Den kan læse dine notifikationer, herunder personlige oplysninger såsom kontakter, beskeder og billeder."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Svare på beskeder"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Den kan besvare beskeder og interagere med knapper i notifikationer, herunder udsættelse eller afvisning af notifikationer og besvarelse af opkald."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Skift indstillinger"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Den kan aktivere eller deaktivere Forstyr ikke og ændre relaterede indstillinger."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Hvis du slår adgang til notifikationer fra for <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, slås adgangen til Forstyr ikke muligvis også fra."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Slå fra"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Annuller"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Realtid"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Løbende kommunikation fra apps, der er i brug, navigation, telefonopkald og meget mere"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Samtaler"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"Sms-beskeder og andre meddelelser"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Notifikationer"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Kan ringe eller vibrere baseret på indstillingerne"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Lydløs"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Notifikationer, der aldrig ringer eller vibrerer"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Har tilladelse"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Har ikke tilladelse"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Se alle apps"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Skift indstillinger for hver app, der sender notifikationer"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Apps, der vises på enheden"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Denne app understøtter ikke avancerede indstillinger"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Flere indstillinger"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Der er flere tilgængelige indstillinger inde i appen"</string>
    <string name="notification_polite_title" msgid="6121016426991791557">"Dæmpning af notifikationer"</string>
    <string name="notification_polite_all_apps" msgid="1118651561594250059">"Anvend dæmpning på alle notifikationer"</string>
    <string name="notification_polite_all_apps_summary" msgid="540268373207498126">"Dæmp gradvist lydstyrken for notifikationer, når du får mange notifikationer i træk fra samme app"</string>
    <string name="notification_polite_conversations" msgid="8197695136727245741">"Anvend dæmpning på alle samtaler"</string>
    <string name="notification_polite_conversations_summary" msgid="2677141765664359994">"Sænk gradvist lydstyrken for notifikationer, når du får mange beskeder fra samme chat på kort tid"</string>
    <string name="notification_polite_disabled" msgid="1378078021594282842">"Brug ikke dæmpning for notifikationer"</string>
    <string name="notification_polite_disabled_summary" msgid="1145341260283746936">"Sænk aldrig lydstyrken for notifikationer, uanset hvor mange notifikationer du får i træk fra samme app"</string>
    <string name="notification_polite_vibrate_unlocked" msgid="6142573851761357903">"Vibrer, når enheden er ulåst"</string>
    <string name="notification_polite_vibrate_unlocked_summary" msgid="1678472892282874459">"Vibrer kun, når skærmen er ulåst"</string>
    <string name="notification_polite_work" msgid="8823596456640216391">"Anvend på arbejdsprofiler"</string>
    <string name="notification_polite_work_summary" msgid="8260947839104352075">"Anvend indstillingen for dæmpning af notifikationer fra din personlige profil på din arbejdsprofil"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"VR-hjælpetjenester"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Ingen installerede apps har anmodet om at blive kørt som VR-hjælpetjenester."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Vil du tillade, at <xliff:g id="SERVICE">%1$s</xliff:g> får adgang til VR-tjenesten?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> vil kunne køre, når du bruger apps i virtual reality-tilstand."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Når enheden er i VR-tilstand"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Reducer sløring (anbefalet)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Reducer flimren"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Integreret billede"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Ingen af de installerede apps understøtter integreret billede"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"integreret billede i"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Integreret billede"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Tillad integreret billede"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Giv tilladelse til, at denne app opretter et vindue med integreret billede, mens appen er åben, eller efter du lukker den (f.eks. for at fortsætte med at se en video). Dette vindue vises oven på andre apps, du bruger."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Samlet appvisning"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Forbundet"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Ikke forbundet"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Der er ingen forbundne apps"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"på tværs af profiler tilknyttet app apps arbejde og personlige"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Tilknyttet"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Forbind disse apps"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Forbundne apps deler tilladelser og har adgang til hinandens data."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Du bør kun forbinde apps, hvis du har tillid til, at de ikke deler personoplysninger med din it-administrator."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Du kan til enhver tid fjerne forbindelsen mellem dine apps i privatlivsindstillingerne for din enhed."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Vil du dele dine personoplysninger med arbejdsappen <xliff:g id="NAME">%1$s</xliff:g>?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Du bør kun forbinde apps, hvis du har tillid til, at de ikke deler personoplysninger med din it-administrator."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Appdata"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Denne app har adgang til data i din personlige <xliff:g id="NAME">%1$s</xliff:g>-app."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Tilladelser"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Denne app kan bruge din personlige <xliff:g id="NAME">%1$s</xliff:g>-apps tilladelser, f.eks. adgang til lokationer, lager eller kontakter."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Der er ingen forbundne apps"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# app er tilknyttet}one{# app er tilknyttet}other{# apps er tilknyttet}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Hvis du vil forbinde disse apps, skal du installere <xliff:g id="NAME">%1$s</xliff:g> på din arbejdsprofil"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Hvis du vil forbinde disse apps, skal du installere <xliff:g id="NAME">%1$s</xliff:g> på din personlige profil"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Tryk for at hente appen"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Adgang til Forstyr ikke"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Tillad Forstyr ikke"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Ingen installerede apps har anmodet om adgang, når indstillingen \"Forstyr ikke\" er aktiveret."</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Du har ikke tilladt notifikationer fra denne app"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Android blokerer på din anmodning notifikationer i denne kategori, så de ikke vises på enheden"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Android blokerer på din anmodning notifikationer i denne gruppe, så de ikke vises på enheden"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Denne app sender ikke notifikationer"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategorier"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Andre"</string>
    <string name="no_channels" msgid="4716199078612071915">"Denne app har ikke sendt nogen notifikationer"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Flere indstillinger i appen"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# kategori er slettet}one{# kategori er slettet}other{# kategorier er slettet}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Bloker alle"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Vis aldrig disse notifikationer"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Vis notifikationer"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Vis aldrig notifikationer i underretningspanelet eller på eksterne enheder"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Tillad notifikationer i fuld skærm"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Tillad notifikationer, der fylder hele skærmen, når enheden er låst"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Tillad notifikationsprik"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Vis notifikationsprik"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Tilsidesæt Forstyr ikke"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Bliv ved med at få disse notifikationer, når Forstyr ikke er aktiveret"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Låseskærm"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Udfør"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Blinkende lys"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibration"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Lyd"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioritet"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Navn på tidsplan"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Angiv tidsplanens navn"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Tidsplanens navn er allerede i brug"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Tilføj flere"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Tilføj tidsplan for begivenhed"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Tilføj tidsplan"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Vælg typen af tidsplan"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Vil du slette reglen \"<xliff:g id="RULE">%1$s</xliff:g>\"?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Slet"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Disse indstillinger kan ikke ændres lige nu. En app (<xliff:g id="APP_NAME">%1$s</xliff:g>) har automatisk aktiveret Forstyr ikke ved hjælp af en tilpasset funktion."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Disse indstillinger kan ikke ændres lige nu. En app har automatisk aktiveret Forstyr ikke ved hjælp af en tilpasset funktion."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Disse indstillinger kan ikke ændres lige nu. Funktionen Forstyr ikke blev aktiveret manuelt ved hjælp af en tilpasset funktion."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Tidspunkt"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Begivenhed"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Til begivenheder fra"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Alle kalendere"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Hvor svaret er"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Ja, Måske eller Ikke besvaret"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Ja eller Måske"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Ja"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Reglen blev ikke fundet."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Til – <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">"Dage"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Ingen"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Alarmen kan tilsidesætte sluttidspunktet"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Tidsplanen deaktiveres, når en alarm ringer"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Adfærd for Forstyr ikke"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Anvend standardindstillinger"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Opret tilpassede indstillinger for denne tidsplan"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"For \"<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">"Samtaler"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Alle samtaler"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Prioriterede samtaler"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"prioriterede samtaler"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Ingen"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Ingen}=1{1 samtale}one{# samtale}other{# samtaler}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Hvem kan afbryde?"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Selv hvis besked- og opkaldsapps ikke kan underrette dig, kan de personer, du vælger her, stadig kontakte dig via de pågældende apps"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Opkald"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Opkald"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"opkald"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Opkald, der kan afbryde"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Hvis du vil sørge for, at tilladte opkald benytter lyd, skal du tjekke, at enheden er indstillet til at ringe"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Indgående opkald blokeres for \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\". Du kan ændre indstillingerne, så dine venner, din familie eller andre kontakter kan få fat i dig."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Stjernemarkerede kontakter"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Ingen}=1{{contact_1}}=2{{contact_1} og {contact_2}}=3{{contact_1}, {contact_2} og {contact_3}}one{{contact_1}, {contact_2} og # mere}other{{contact_1}, {contact_2} og # andre}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Intet navn)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Beskeder"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"beskeder"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Beskeder"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Beskeder, der kan afbryde"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Hvis du vil være sikker på, at tilladte beskeder benytter lyd, skal du tjekke, at enheden er indstillet til at ringe"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Indgående beskeder er blokeret for \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\". Du kan ændre indstillingerne, så dine venner, din familie eller andre kontakter kan få fat i dig."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Du modtager alle beskeder"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Du modtager alle opkald"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Ingen}=1{1 kontakt}one{# kontakt}other{# kontakter}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Alle"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontakter"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Stjernemarkerede kontakter"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Ingen"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Ingen"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarmer"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Fra timere, alarmer, sikkerhedssystemer og andre apps"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"alarmer"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Alarmer"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Lyd fra medier"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Lyde fra videoer, spil og andre medier"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"medier"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Medier"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Lyd ved berøring"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Lyde fra tastaturet og andre knapper"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"lyd ved berøring"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Lyd ved berøring"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Påmindelser"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Fra opgaver og påmindelser"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"påmindelser"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Påmindelser"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Kalenderbegivenheder"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Fra kommende kalenderbegivenheder"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"begivenheder"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Begivenheder"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Tillad, at apps tilsidesætter"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Apps, der kan afbryde"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Vælg flere apps"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Ingen apps er valgt"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Ingen apps kan afbryde"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Tilføj apps"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Alle notifikationer"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Nogle notifikationer"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Valgte personer kan stadig kontakte dig, selv hvis du ikke tillader, at apps kan afbryde"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Ingen apps kan afbryde}=1{{app_1} kan afbryde}=2{{app_1} og {app_2} kan afbryde}=3{{app_1}, {app_2} og {app_3} kan afbryde}one{{app_1}, {app_2} og # mere kan afbryde}other{{app_1}, {app_2} og # andre kan afbryde}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Apps"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Notifikationer, der kan afbryde"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Tillad alle notifikationer"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Intet kan afbryde}=1{{sound_category_1} kan afbryde}=2{{sound_category_1} og {sound_category_2} kan afbryde}=3{{sound_category_1}, {sound_category_2} og{sound_category_3} kan afbryde}one{{sound_category_1}, {sound_category_2} og # mere kan afbryde}other{{sound_category_1}, {sound_category_2} og # andre kan afbryde}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Intet kan afbryde"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Ingen kan afbryde"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Nogle personer kan afbryde"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Alle personer kan afbryde"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Gentagne opkald"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Tillad gentagne opkald"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"alle"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"kontakter"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"stjernemarkerede kontakter"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"gentagne opkald"</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> og <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Hvis den samme person ringer igen inden for <xliff:g id="MINUTES">%d</xliff:g> minutter"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Starttidspunkt"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Sluttidspunkt"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> næste dag"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Skift til Kun alarmer på ubestemt tid"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Skift til kun alarmer i ét minut (indtil {time})}one{Skift til kun alarmer i # minut (indtil {time})}other{Skift til kun alarmer i # minutter (indtil {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Skift til kun alarmer i én time (indtil {time})}one{Skift til kun alarmer i # time (indtil {time})}other{Skift til kun alarmer i # timer (indtil {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Skift til Kun alarmer frem til <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Skift til Afbryd altid"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Advarsel"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Luk"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Send feedback om denne enhed"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Angiv administratorpinkoden"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Til"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Fra"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Til"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Fra"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Til"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Fra"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Appfastgørelse"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Med appfastgørelse kan du beholde den aktuelle app i visningen, indtil du frigør den. Denne funktion kan f.eks. anvendes til at give en ven, du har tillid til, mulighed for at spille et specifikt spil."</string>
    <string name="screen_pinning_description" msgid="5822120806426139396">"Når en app fastgøres, kan den fastgjorte app muligvis åbne andre apps og få adgang til private data. \n\nSådan bruger du appfastgørelse: 	\n{0,number,integer}. Slå appfastgørelse til 	\n{1,number,integer}. Åbn Oversigt 	\n{2,number,integer}. Tryk på appikonet øverst på skærmen, og tryk derefter på Fastgør"</string>
    <string name="screen_pinning_guest_user_description" msgid="2307270321127139579">"Når en app fastgøres, kan den fastgjorte app muligvis åbne andre apps og få adgang til private data. \n\nHvis du vil dele din enhed med en anden på en sikker måde, kan du prøve at bruge en gæstebruger i stedet. \n\nSådan bruger du appfastgørelse: 	\n{0,number,integer}. Slå appfastgørelse til 	\n{1,number,integer}. Åbn Oversigt 	\n{2,number,integer}. Tryk på appikonet øverst på skærmen, og tryk derefter på Fastgør"</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Når en app er fastgjort: \n\n•	 Personoplysninger kan muligvis tilgås \n		(f.eks. kontakter og mailindhold) \n•	 Den fastgjorte app kan muligvis åbne andre apps \n\nBrug kun appfastgørelse til brugere, du har tillid til."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Bed om oplåsningsmønster inden frigørelse"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Bed om pinkode inden frigørelse"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Bed om adgangskode inden frigørelse"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Lås enheden ved frigørelse"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Bekræft sletning af SIM"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Verificer din identitet, inden du rydder et eSIM"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Avanceret beskyttelse af hukommelsen (beta)"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Avanceret beskyttelse af hukommelsen"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Denne betafunktion hjælper dig med at beskytte din enhed mod fejl, der kan bringe din sikkerhed i fare."</string>
    <string name="memtag_on" msgid="824938319141503923">"Til"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Fra"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Til efter genstart"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Fra efter genstart"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Fås i øjeblikket ikke til din enhed"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Altid aktiveret på din enhed"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Genstart din enhed for at aktivere eller deaktivere avanceret beskyttelse af hukommelsen. Når funktionen er aktiveret, vil du muligvis opleve, at enheden er langsommere."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Vil du genstarte enheden?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Genstart din enhed for at aktivere avanceret beskyttelse af hukommelsen."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Genstart din enhed for at deaktivere avanceret beskyttelse af hukommelsen."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Genstart"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Ikke nu"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Få flere oplysninger om avanceret beskyttelse af hukommelsen."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Denne arbejdsprofil administreres af:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Administreret af <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Åbn som standard"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Åbn understøttede links"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Tillad, at weblinks kan åbnes i denne app"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Links, der skal åbnes i denne app"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Understøttede links"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Andre standardpræferencer"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Tilføj link"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"En app kan verificere links, så de automatisk åbnes i appen."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# verificeret link}one{# verificeret link}other{# verificerede links}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Dette link er verificeret og åbnes automatisk i denne app.}one{Dette link er verificeret og åbnes automatisk i denne app.}other{Disse links er verificeret og åbnes automatisk i denne app.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"OK"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Vis liste over verificerede links"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Søger efter andre understøttede links…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Annuller"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# understøttet link}one{# understøttet link}other{# understøttede links}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Tilføj"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Åbnes i <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> brugt i <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"intern lagerplads"</string>
    <string name="storage_type_external" msgid="125078274000280821">"ekstern lagerplads"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> brugt siden <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Anvendt lagerplads"</string>
    <string name="change" msgid="273206077375322595">"Skift"</string>
    <string name="change_storage" msgid="8773820275624113401">"Skift lager"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Notifikationer"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Til"</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">"Fra"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# kategori er deaktiveret}one{# kategori er deaktiveret}other{# kategorier er deaktiveret}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# yderligere tilladelse}one{# yderligere tilladelse}other{# yderligere tilladelser}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Der er ikke givet nogen tilladelser"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Der er ikke anmodet om nogen tilladelser"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Administrer appadgang til dine data"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Privatlivspanel"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Vis, hvilke apps der har brugt tilladelser for nylig"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Apps, du ikke bruger"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# ubrugt app}one{# ubrugt app}other{# ubrugte apps}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Ubrugte appindstillinger"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Sæt appaktivitet på pause ved inaktivitet"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Fjern tilladelser, slet midlertidige filer, og stop notifikationer"</string>
    <string name="unused_apps_switch_v2" msgid="7464060328451454469">"Administrer appen, hvis den ikke bruges"</string>
    <string name="unused_apps_switch_summary_v2" msgid="3182898279622036805">"Fjern tilladelser, slet midlertidige filer, deaktiver notifikationer, og arkivér appen"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Alle apps"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Installerede apps"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Instant-apps"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Slået fra"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Avanceret"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Tilladelsesadministrator"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Opdateringer af datadeling for lokation"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Gennemse apps, der har ændret måden, de kan dele dine lokationsdata på"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Tryk for at vække"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Tryk to gange et vilkårligt sted på skærmen for at vække enheden"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Åbning af links"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Åbn ikke understøttede links"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Åbn <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Åbn <xliff:g id="DOMAIN">%s</xliff:g> og andre webadresser"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Giv appen tilladelse til at åbne understøttede links"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Spørg hver gang"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Giv ikke appen tilladelse til at åbne links"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Appen påstår, at den håndterer # link}one{Appen påstår, at den håndterer # link}other{Appen påstår, at den håndterer # links}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Appen påstår, at den håndterer de følgende links:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Assistance og indtaling"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"App for digital assistent"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Standardapp for digital assistent"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Acceptér"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Browserapp"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Opkaldsapp"</string>
    <string name="system_app" msgid="1863291702508355041">"(System)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Applagerplads"</string>
    <string name="usage_access" msgid="5487993885373893282">"Adgang til brugsdata"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Tillad adgang til telefonbrug"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Skærmtid"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Med adgang til brugsdata kan en app læse, hvilke andre apps du anvender og hvor ofte, samt dit mobilselskab, dine sprogindstillinger og andre oplysninger."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Hukommelse"</string>
    <string name="always_running" msgid="9012705720688200252">"Kører altid (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Kører nogle gange (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Kører sjældent (<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">"Batterioptimering"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Ikke-optimeret"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Ikke-optimeret"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimerer batteriforbruget"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Batterioptimering er ikke tilgængelig"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Vil du give appen tilladelse til altid at køre i baggrunden?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Hvis du giver <xliff:g id="APP_NAME">%1$s</xliff:g> tilladelse til altid at køre i baggrunden, kan det gå ud over batteritiden. \n\nDu kan ændre dette på et senere tidspunkt under Indstillinger &gt; Apps."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> brugt siden sidste fulde opladning"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> er anvendt i løbet af de seneste 24 timer"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Intet batteriforbrug siden seneste fulde opladning"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Vil du dele fejlrapporten?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Din it-administrator har anmodet om en fejlrapport for bedre at kunne finde og rette fejlen på enheden. Apps og data deles muligvis."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Din it-administrator har anmodet om en fejlrapport for bedre at kunne finde og rette fejlen på enheden. Apps og data deles muligvis, og din enhed kan midlertidigt blive langsommere."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Denne fejlrapport deles med din it-administrator. Kontakt vedkommende for at få flere oplysninger."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Del"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Afvis"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Ingen dataoverførsel"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Oplad tilsluttet enhed"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Filoverførsel"</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">"Konverter videoer til AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Videoer afspilles på flere medieafspillere, men dette kan gå ud over kvaliteten."</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Netdeling via USB"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Brug USB til"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Standardkonfiguration for USB"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Disse indstillinger anvendes, når der er oprettet forbindelse til en anden enhed, og din telefon er ulåst. Opret kun forbindelse til godkendte enheder."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Indstillinger for afbryderknappen"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Muligheder for filoverførsel"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"USB-præferencer"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB styres af"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Forbundet med enhed"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Denne enhed"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Skifter…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Der kunne ikke skiftes"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Oplader denne enhed"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Den tilsluttede enhed oplades"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Filoverførsel"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Netdeling via USB"</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">"Filoverførsel og strømforsyning"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Netdeling via USB og strømforsyning"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP og strømforsyning"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI og strømforsyning"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Webcam og strømforsyning"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Baggrundstjek"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Brug tekst fra skærmen"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Giv assistanceappen adgang til skærmens indhold som tekst"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Brug screenshot"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Giv assistanceappen adgang til et billede af skærmen"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Blink på skærmen"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Blink langs skærmens kanter, når assistanceappen har adgang til tekst fra skærmen eller et screenshot"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Assistanceapps kan hjælpe dig med afsæt i oplysningerne på den aktuelle skærm. Nogle apps understøtter både startertjenester og tjenester til indtaling for at give dig integreret assistance."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Gennemsnitligt hukommelsesforbrug"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maksimal hukommelsesforbrug"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Hukommelsesforbrug"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Appbrug"</string>
    <string name="memory_details" msgid="6133226869214421347">"Info"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Der er i gennemsnit brugt <xliff:g id="SIZE">%1$s</xliff:g> hukommelse inden for de sidste tre timer"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Der er ikke brugt hukommelse inden for de sidste tre timer"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Sortér efter gennemsnitligt forbrug"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Sortér efter maksimal forbrug"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Ydelse"</string>
    <string name="total_memory" msgid="5244174393008910567">"Hukommelse i alt"</string>
    <string name="average_used" msgid="690235917394070169">"Brugt i gennemsnit (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Ledig"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Hukommelse, der bruges af apps"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 app har brugt hukommelse inden for den seneste {time}}one{# app har brugt hukommelse inden for den seneste {time}}other{# apps har brugt hukommelse inden for den seneste {time}}}"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Hyppighed"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maksimal forbrug"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Der blev ikke brugt nogen data"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Vil du give <xliff:g id="APP">%1$s</xliff:g> adgang til Forstyr ikke?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Appen vil kunne aktivere/deaktivere Forstyr ikke og foretage ændringer i relaterede indstillinger."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Skal være slået til, fordi adgangen til notifikationer er slået til"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Vil du tilbagekalde adgangen til Forstyr ikke for <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Alle Forstyr ikke-regler, der er oprettet af denne app, fjernes."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Undlad at optimere"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimer"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Dette kan dræne batteriet hurtigere. Appen forhindres ikke længere i at bruge batteri i baggrunden."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Anbefales for længere batteritid"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Ingen"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Selvom du deaktiverer denne apps adgang til telefonbrug, kan din administrator stadig holde øje med dataforbruget i apps på din arbejdsprofil"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Vis oven på andre apps"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Vis oven på andre apps"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Tillad visning over andre apps"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Tillad, at denne app vises oven på de andre apps, du bruger. Denne app kan registrere, hvor du trykker, eller ændre det, der vises på skærmen."</string>
    <string name="media_routing_control_title" msgid="6402800638960066807">"Skift medieoutput"</string>
    <string name="allow_media_routing_control" msgid="4907036637509360616">"Tillad at appen skifter medieoutput"</string>
    <string name="allow_media_routing_description" msgid="8343709701298051207">"Giv denne app tilladelse til at vælge, hvilken forbundet enhed der afspiller lyd eller video fra andre apps. Hvis du giver tilladelse, kan denne app få adgang til en liste over tilgængelige enheder som f.eks. høretelefoner og højttalere og vælge, hvilken outputenhed der skal bruges til at streame eller caste lyd eller video."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Adgang til alle filer"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Tillad administrationsadgang til alle filer"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Giv denne app tilladelse til at læse, ændre og slette alle filer på denne enhed eller andre tilsluttede lagringsløsninger. Hvis du giver tilladelse til dette, kan appen få adgang til dine filer, uden du specifikt bliver gjort opmærksom på det."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Kan få adgang til alle filer"</string>
    <string name="voice_activation_apps_title" msgid="7130045161611529825">"Stemmeaktiverede apps"</string>
    <string name="permit_voice_activation_apps" msgid="9152780172988949319">"Tillad stemmeaktivering"</string>
    <string name="allow_voice_activation_apps_description" msgid="6369745626995060656">"Stemmeaktivering aktiverer godkendte apps håndfrit ved hjælp af stemmekommandoer. Indbygget adaptiv registrering sørger for, at dine private data forbliver beskyttet.\n\n"<a href="">"Få flere oplysninger om beskyttelse med adaptiv registrering"</a></string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Notifikationer i fuld skærm"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Tillad notifikationer i fuld skærm fra denne app"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Tillad appen at vise notifikationer, der fylder hele skærmen, når enheden er låst. Apps kan benytte denne mulighed til at fremhæve alarmer, indgående opkald og andre presserende notifikationer."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Apps til administration af medier"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Tillad, at appen administrerer medier"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Hvis du tillader dette, kan denne app redigere og slette mediefiler, der er oprettet med andre apps, uden at spørge dig. Appen skal have adgangstilladelse til filer og medier."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Medier, Fil, Administration, Administrator, Administrer, Rediger, Redigeringsværktøj, App, Applikation, Program"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr virtual reality lyttefunktion stereo hjælpetjeneste"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Vis oven på andre apps"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Apps med tilladelse"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Tilladt"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Ikke tilladt"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"installer apps fra ukendte kilder"</string>
    <string name="write_settings" msgid="6864794401614425894">"Rediger systemindstillinger"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"redigere ændre systemindstillinger"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Kan installere andre apps"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Kan ændre systemindstillinger"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Kan ændre systemindstillinger"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Rediger systemindstillinger"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Tillad ændring af systemindstillinger"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Denne tilladelse giver en app lov til at ændre systemindstillinger."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Tillad fra denne kilde"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Drej to gange for at åbne kameraet"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Åbn kameraappen ved at dreje håndleddet to gange"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Skærmstørrelse"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Gør alt større eller mindre"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"visningstæthed, zoom på skærmen, skala, skalering"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Forhåndsvisning"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Formindsk"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Forstør"</string>
    <string name="disconnected" msgid="3469373726996129247">"Ikke forbundet"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Ikke tilsluttet"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> apps er installeret"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> er brugt – <xliff:g id="FREE_SPACE">%2$s</xliff:g> ledig plads"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Mørkt tema, skriftstørrelse, lysstyrke"</string>
    <string name="memory_summary" msgid="8221954450951651735">"I gennemsnit er <xliff:g id="USED_MEMORY">%1$s</xliff:g> ud af <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> hukommelse anvendt"</string>
    <string name="users_summary" msgid="8473589474976307510">"Logget ind som <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Opdateret til Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Der er en tilgængelig opdatering"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Blokeret af din arbejdspolitik"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Lydstyrken kan ikke ændres"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Der kan ikke foretages opkald"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Der kan ikke sendes sms-beskeder"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Kameraet kan ikke bruges"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Der kan ikke tages screenshots"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Denne app kan ikke åbnes"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Blokeret af dit kreditinstitut"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Dette kræver en forælder"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Giv telefonen til din forælder for at starte konfigurationen af dette"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Giv telefonen til din forælder, så din forælder kan tillade, at denne indstilling ændres."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Få flere oplysninger ved at kontakte din it-administrator."</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Flere oplysninger"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Din administrator kan overvåge og administrere apps og data, der er knyttet til din arbejdsprofil, herunder indstillinger, tilladelser, virksomhedsadgang, netværksaktivitet og enhedens lokationsoplysninger."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Din administrator kan overvåge og administrere apps og data, der er knyttet til denne bruger, herunder indstillinger, tilladelser, virksomhedsadgang, netværksaktivitet og enhedens lokationsoplysninger."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Din administrator kan overvåge og administrere apps og data, der er knyttet til denne enhed, herunder indstillinger, tilladelser, virksomhedsadgang, netværksaktivitet og enhedens lokationsoplysninger."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Din enhedsadministrator kan muligvis administrere apps, få adgang til data, der er tilknyttet denne enhed, og ændre enhedens indstillinger."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Slå fra"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Aktivér"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Vis"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Skjul"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Hotspot er aktiveret"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Flytilstand er slået til"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Ingen tilgængelige netværk"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Forstyr ikke er aktiveret"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Telefonen er på lydløs"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Med undtagelser"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Batterisparefunktion er slået til"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funktionerne er begrænsede"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobildata er deaktiveret"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Der er kun internetadgang via Wi-Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Datasparefunktion"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funktionerne er begrænsede"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Arbejdsprofilen er slået fra"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"For apps og notifikationer"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Tænd for lyden"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Ringesignal er slået fra"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"For opkald og notifikationer"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Kun vibration"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"For opkald og notifikationer"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Angiv tidsplan for Nattelys"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Nedton automatisk skærmen hver nat"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Nattelys er slået til"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Farvenuancen på skærmen er orangegul"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Gråtoner"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Vis kun i gråtoner"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Skjul"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Kølig farvetemperatur"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Brug køligere skærmfarver"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Du skal slå skærmen fra, før du kan anvende farveændringer"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Kameraets lasersensor"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automatiske systemopdateringer"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Anvend opdateringer, når enheden genstarter"</string>
    <string name="usage" msgid="287782903846013936">"Forbrug"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Mobildataforbrug"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Dataforbrug i apps"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Dataforbrug via Wi-Fi"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Dataforbrug for andre netværk"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Forbrug af Ethernet-data"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> mobildata"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> Wi-Fi-data"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> Ethernet-data"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Dataadvarsel og -grænse"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Cyklus for mobildataforbrug"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Dataadvarsel ved <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Datagrænse på <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Dataadvarsel ved <xliff:g id="ID_1">^1</xliff:g>/datagrænse på <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Omfatter ikke data, der anvendes af mobilnetværk"</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> brugt"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Konfigurer dataadvarsel"</string>
    <string name="data_warning" msgid="2925054658166062884">"Dataadvarsel"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Dataadvarsel og datagrænse måles af din enhed. Dit mobilselskabs måling kan afvige."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Angiv datagrænse"</string>
    <string name="data_limit" msgid="8731731657513652363">"Datagrænse"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_1">%1$s</xliff:g> brugt <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Konfigurer"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Andre apps, der er inkluderet i forbruget"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 app har tilladelse til at bruge ubegrænsede data, når datasparefunktionen er aktiveret}one{# app har tilladelse til at bruge ubegrænsede data, når datasparefunktionen er aktiveret}other{# apps har tilladelse til at bruge ubegrænsede data, når datasparefunktionen er aktiveret}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Primære data"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Wi‑Fi-data"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"<xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> data brugt"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Overskredet med <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Der er <xliff:g id="ID_1">^1</xliff:g> tilbage"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Graf, der viser dataforbrug mellem den <xliff:g id="START_DATE">%1$s</xliff:g> og <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Der er ingen data i dette datointerval"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{# dag tilbage}one{# dag tilbage}other{# dage tilbage}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Der er ingen resterende tid"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Der er mindre end 1 dag tilbage"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Opdateret af <xliff:g id="ID_1">^1</xliff:g> for <xliff:g id="ID_2">^2</xliff:g> siden"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Opdateret for <xliff:g id="ID_1">^2</xliff:g> siden"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Netop opdateret af <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Netop opdateret"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Se oplysninger"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Datasparefunktion"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Ubegrænset data"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Baggrundsdata er deaktiveret"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Til"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Fra"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Brug datasparefunktion"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Ubegrænset dataforbrug"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Tillad ubegrænset dataadgang, selvom datasparefunktionen er aktiveret"</string>
    <string name="home_app" msgid="6056850504746902747">"Startapp"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Tilføj et fingeraftryk mere"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Lås op med en anden finger"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Til"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Aktiveres ved <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Fra"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Batteriforbrug for apps"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Indstil batteriforbrug for apps"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"Se indstillinger"</string>
    <string name="battery_tips_card_action_button_check" msgid="1535140204105479318">"Tjek"</string>
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"OK"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"Er denne meddelelse nyttig?"</string>
    <string name="battery_hints_warning_icon_a11y" msgid="5312542323401447620">"Advarselsikon med batteritips"</string>
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Aktivér automatisk lysstyrke for at forlænge batteritiden"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Reducer timeout for skærm for at forlænge batteritiden"</string>
    <string name="battery_tips_apps_summary_always_high" msgid="6334519477067044920">"<xliff:g id="APP_LABEL">%1$s</xliff:g> brugte mere batteri"</string>
    <string name="battery_tips_apps_summary_higher_than_usual" msgid="95676961671544628">"<xliff:g id="APP_LABEL">%1$s</xliff:g> brugte mere batteri end normalt"</string>
    <string name="battery_tips_apps_summary_always_high_in_background" msgid="2953858181710181126">"<xliff:g id="APP_LABEL">%1$s</xliff:g> brugte mere batteri i baggrunden"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_background" msgid="1585002072567422199">"<xliff:g id="APP_LABEL">%1$s</xliff:g> brugte mere batteri end normalt i baggrunden"</string>
    <string name="battery_tips_apps_summary_always_high_in_foreground" msgid="1910991243576404700">"<xliff:g id="APP_LABEL">%1$s</xliff:g> brugte mere batteri i forgrunden"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground" msgid="7937337570425168210">"<xliff:g id="APP_LABEL">%1$s</xliff:g> brugte mere batteri end normalt i forgrunden"</string>
    <string name="battery_usage_anomaly_content_description" msgid="3199380151630770476">"Afvigelse i batteriforbrug"</string>
    <string name="battery_app_item_hint" msgid="4850929961461039110">"Højt batteriforbrug"</string>
    <string name="battery_app_item_hint_in_bg" msgid="596240821466388336">"Højt batteriforbrug i baggrunden"</string>
    <string name="battery_app_item_hint_in_fg" msgid="5091860632260799910">"Højt batteriforbrug i forgrunden"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Ubegrænset"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimeret"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Begrænset"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Standardstavekontrol"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Vælg stavekontrol"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Brug stavekontrol"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Ikke valgt"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pakke"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"nøgle"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"gruppe"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(oversigt)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"publicVersion"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"vigtighed"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"forklaring"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"kan vise badge"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"formål"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"slet formål"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"formål for fuld skærm"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"handlinger"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"titel"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"fjerninput"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"tilpasset visning"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"ekstra oplysninger"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikon"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"pakkestørrelse"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"underrettet via notifikation"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanal"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Rangeringsobjektet mangler."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Rangeringobjektet indeholder ikke denne nøgle."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Skærmhak"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"udskæring på skærmen, hak"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Enhedens standardindstilling"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Overlejringen kunne ikke anvendes"</string>
    <string name="special_access" msgid="1767980727423395147">"Særlig appadgang"</string>
    <string name="special_access_more" msgid="132919514147475846">"Se mere"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Lange baggrundsopgaver"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Tillad længerevarende opgaver i baggrunden"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Lange baggrundsopgaver"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Giv denne app tilladelse til at køre lange opgaver i baggrunden. Dette giver appen mulighed for at køre opgaver, som muligvis varer længere tid end et par minutter. Det kan f.eks. være downloads og uploads. \n\nHvis denne tilladelse afvises, begrænser systemet, hvor lang tid appen kan bruge på at udføre sådanne opgaver i baggrunden."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"lange opgaver, dataoverførsel, baggrundsopgaver"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Nulstil antalsbegrænsning i ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Antalsbegrænsning i ShortcutManager er nulstillet"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Styr, hvad der vises på din låseskærm"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Vis eller skjul indhold i notifikationer"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Support og tips"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Mindste bredde"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Ingen installerede apps har anmodet om adgang til overtakseret sms"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Overtakseret sms kan koste dig penge, som opkræves via din mobilregning. Hvis du aktiverer tilladelsen for en app, kan du sende overtakserede sms-beskeder ved hjælp af denne app."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Adgang til overtakseret sms"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Deaktiveret"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Forbundet med <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Forbundet med flere enheder"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Demotilstand for systemets brugerflade"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Mørkt tema"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Midlertidigt deaktiveret på grund af batterisparefunktionen"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Midlertidigt deaktiveret på grund af Batterisparefunktion"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Deaktiver Batterisparefunktion"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Midlertidigt aktiveret af batterisparefunktionen"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Prøv Mørkt tema"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Forlænger batteritiden"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Felter for udviklere til Kvikmenu"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Deaktiver timeout for adb-godkendelser"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Deaktiver automatisk tilbagekaldelse af adb-godkendelser for systemer, der ikke har genoprettet forbindelsen indenfor standardperioden (7 dage) eller den brugerkonfigurerede tidsperiode (mindst 1 dag)."</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Sensorer er slået fra"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Indstillinger for arbejdsprofil"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Søg efter kontakter ved hjælp af indekset for arbejdsprofil i personlige apps"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Dine søgninger og indgående opkald kan muligvis ses af din it-administrator"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kalender for flere profiler"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Se arbejdsbegivenheder i din personlige kalender"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Når arbejdsapps er deaktiveret, sættes de på pause og kan ikke tilgås eller sende dig notifikationer"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Administrer lagerplads"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"For at hjælpe med at frigøre lagerplads fjerner Lageradministrator sikkerhedskopierede billeder og videoer fra din enhed."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Fjern billeder og videoer"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Lageradministrator"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Brug Lageradministrator"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Bevægelser"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Åbn hurtigt kameraet"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Du kan åbne dit kamera hurtigt ved at trykke to gange på afbryderknappen. Denne genvej fungerer fra enhver skærm."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Vend kameraet for at tage en selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Navigationstilstand"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigering med to knapper"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Stryg opad på knappen Hjem for at skifte mellem apps. Stryg opad igen for at se alle apps. Tryk på tilbageknappen for at gå tilbage."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Sikkerhed og nødsituationer"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Nødkald, helbredsoplysninger, underretninger"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigering med bevægelser"</string>
    <string name="edge_to_edge_navigation_summary" msgid="818109176611921504">"Gå til startskærmen ved at stryge opad fra bunden af skærmen. Skift mellem apps ved at stryge opad fra bunden af skærmen, holde fingeren nede og derefter give slip. Gå tilbage ved at stryge fra enten venstre eller højre kant."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navigering med tre knapper"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Gå tilbage, gå til startskærmen og skift mellem apps ved hjælp af knapperne nederst på din skærm."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"systemnavigation, navigering med to knapper, navigering med tre knapper, navigering med bevægelser, stryg"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digital assistent"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Stryg for at aktivere assistenten"</string>
    <string name="assistant_corner_gesture_summary" msgid="5012534700233017955">"Stryg opad fra et af de nedre hjørner for at aktivere appen for din digitale assistent."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Hold knappen Hjem nede for at aktivere Assistent"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Hold knappen Hjem nede for at aktivere appen for den digitale assistent."</string>
    <string name="low_label" msgid="6525629096999711220">"Lav"</string>
    <string name="high_label" msgid="357503396626018487">"Høj"</string>
    <string name="left_edge" msgid="1513576842959071849">"Venstre kant"</string>
    <string name="right_edge" msgid="1505309103265829121">"Højre kant"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Højere følsomhed kan komme i konflikt med appbevægelser langs skærmens kant."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Følsomhed for bevægelse fra kant"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Følsomhed af navigation med bevægelser"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Navigation med knapper"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigation med bevægelser, følsomhed for bevægelse fra kant, bevægelse til at gå tilbage"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigation, knappen Hjem"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Enhåndstilstand"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Brug enhåndstilstand"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Genvej til enhåndstilstand"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"brug med en hånd"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Stryg nedad for at"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Brug genvejen til"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Træk den øverste halvdel af din skærm ned, så den er lettere at nå med én hånd"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Sådan bruger du enhåndstilstanden"</b>\n" • Sørg for, at navigation med bevægelser er valgt i indstillingerne for systemnavigation\n • Stryg nedad mod bunden af skærmen"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Trække skærmen inden for rækkevidde"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Den øverste del af skærmen flyttes, så du kan nå den med din tommelfinger."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Vise notifikationer"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Notifikationer og indstillinger vises."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Tryk to gange på skærmen for at se klokkeslæt, notifikationer og andre oplysninger."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Aktivering af skærm"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Tryk på skærmen for at se klokkeslæt, notifikationer og andre oplysninger."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Nødkald"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Brug Nødkald"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Start nedenstående handlinger ved at trykke på afbryderknappen hurtigt 5 gange eller mere"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Afspil nedtællingsalarm"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Afspil en høj lyd, når Nødkald starter"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Kontakt i nødsituationer"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Ring efter hjælp"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Telefonnummer, der kan kontaktes for at få hjælp"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Tryk for at redigere"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Hvis du angiver et nummer, der ikke er et alarmnummer:\n • Din enhed skal låses op, før du kan bruge Nødkald\n • Dit opkald besvares muligvis ikke"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Stryg over fingeraftrykslæser for at se notifikationer"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Stryg fingeraftryk"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Se notifikationer hurtigt"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Til"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Fra"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Bootloaderen er allerede låst op"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Opret internetforbindelse, eller kontakt dit mobilselskab"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Indstillingen er ikke tilgængelig på SIM-låste enheder"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Genstart enheden for at aktivere funktionen Enhedsbeskyttelse."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"<xliff:g id="SIZE">%1$s</xliff:g> blev frigjort\n\nSidst kørt den <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">"Åbn links i apps – selv hvis de ikke er installeret"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Instant-apps"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Præferencer for Instant Apps"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Installerede apps"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Din lagerplads administreres nu af Lageradministrator"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Konti for <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Synkroniser automatisk appdata"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Giv apps tilladelse til at opdatere data automatisk"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Kontosynkronisering"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Synkronisering er aktiveret for <xliff:g id="ID_1">%1$d</xliff:g> ud af <xliff:g id="ID_2">%2$d</xliff:g> elementer"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Synkronisering er aktiveret for alle elementer"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Synkronisering er deaktiveret for alle elementer"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Oplysninger om administrerede enheder"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Ændringer og indstillinger, der administreres af din organisation"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Ændringer og indstillinger, der administreres af <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Din organisation kan ændre indstillingerne og installere software på din enhed for at give adgang til dine arbejdsdata. \n\nDu kan få flere oplysninger ved at kontakte din organisations administrator."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Typer oplysninger, din organisation kan se"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Ændringer, der er foretaget af organisationens administrator"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Din adgang til denne enhed"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Data, der er tilknyttet din arbejdskonto, f.eks. mail og kalender"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Liste over apps på din enhed"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Tid og data, der er brugt i hver app"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Seneste historik for netværkstrafik"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Den seneste fejlrapport"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Den seneste sikkerhedslogfil"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Ingen"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Installerede apps"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Antallet af apps er et skøn. Apps, der er blevet installeret uden for Play Butik, er muligvis ikke medregnet."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Mindst # app}one{Mindst # app}other{Mindst # apps}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Lokationstilladelser"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Adgangstilladelser til mikrofon"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Adgangstilladelser til kamera"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Standardapps"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# app}one{# app}other{# apps}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Standardtastatur"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Indstillet til <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"\"Konstant VPN\" er aktiveret"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"\"Konstant VPN\" er aktiveret på din personlige profil"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"\"Konstant VPN\" er aktiveret på din arbejdsprofil"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Global HTTP-proxy er konfigureret"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Pålidelige loginoplysninger"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Pålidelige loginoplysninger på din personlige profil"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Pålidelige loginoplysninger på din arbejdsprofil"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Mindst # CA-certifikat}one{Mindst # CA-certifikat}other{Mindst # CA-certifikater}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Administratoren kan låse enheden og nulstille adgangskoden"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Administratoren kan slette alle data på enheden"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Det maksimale antal mislykkede adgangskodeforsøg, inden alle data på enheden slettes"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Det maksimale antal mislykkede adgangskodeforsøg, inden data på arbejdsprofilen slettes"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# forsøg}one{# forsøg}other{# forsøg}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Denne enhed administreres af din organisation."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Denne enhed administreres af <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Få flere oplysninger"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Begrænset indstilling"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Begrænsede indstillinger tilladt for <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Af hensyn til din sikkerhed er denne indstilling i øjeblikket ikke tilgængelig."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Oplysninger om finansieret enhed"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Din kreditudbyder kan ændre indstillinger og installere software på denne enhed under konfigurationen.\n\nHvis du glemmer en betaling, kan din kreditudbyder låse din enhed og ændre enhedsindstillingerne.\n\nKontakt din kreditudbyder for at få flere oplysninger."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Hvis din enhed er købt på afbetaling, kan du ikke:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Installere apps uden for Play Butik"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Genstarte din enhed i sikker tilstand"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Føje flere brugere til din enhed"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Skifte dato, klokkeslæt og tidszoner"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Bruge Indstillinger for udviklere"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Din kreditudbyder kan:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Få adgang til dit IMEI-nummer"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Gendanne fabriksindstillingerne på din enhed, hvis noget går galt."</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Hvis din enhed er låst, kan du kun bruge den til at:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Foretage nødopkald"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Se systemoplysninger som f.eks. dato, klokkeslæt, netværksstatus og batteri"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Tænde eller slukke for din enhed"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Se notifikationer og sms-beskeder"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Få adgang til apps, der tillades af kreditudbyderen"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Når du har betalt det fulde beløb:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Fjernes alle begrænsninger fra enheden"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Du kan afinstallere kreditorappen"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Oplysninger om finansieret enhed"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Kameraapp}one{Kameraapp}other{Kameraapps}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Kalenderapp"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"App til kontakter"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{Mailklientapp}one{Mailklientapp}other{Mailklientapps}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Kortapp"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Opkaldsapp}one{Opkaldsapp}other{Opkaldsapps}}"</string>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <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>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_default_internal_storage" msgid="4055660218818688131">"Denne enhed"</string>
    <string name="storage_games" msgid="1176568610086802469">"Spil"</string>
    <string name="storage_files" msgid="7968460921272772299">"Filer"</string>
    <string name="storage_images" msgid="2055893015567979387">"Billeder"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videoer"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Lyd"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Apps"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumenter og andet"</string>
    <string name="storage_system" msgid="8472410119822911844">"System"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Papirkurv"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Vil du tømme papirkurven?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Der er <xliff:g id="TOTAL">%1$s</xliff:g> filer i papirkurven. Alle elementerne slettes permanent, og du vil ikke have mulighed for at gendanne dem."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Papirkurven er tom"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Tøm papirkurv"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"Der er brugt <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> i alt"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Ryd appen"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Vil du fjerne denne instant-app?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Åbn"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Spil"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Anvendt lagerplads"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(afinstalleret for brugeren <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(deaktiveret for brugeren <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Autofyld-tjeneste"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Standardtjeneste til autofyld"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Adgangskoder"</string>
    <string name="credman_chosen_app_title" msgid="872524130208251505">"Adgangskoder, adgangsnøgler og datatjenester"</string>
    <string name="credman_credentials" msgid="4931371941253324143">"Yderligere udbydere"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# adgangskode}one{# adgangskode}other{# adgangskoder}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automatisk, udfyld, autofyld, adgangskode"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"data, adgangsnøgle, adgangskode"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"automatisk, udfyldning, autofyld, data, adgangsnøgle, adgangskode"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Sørg for, at du har tillid til denne app&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; anvender indholdet af din skærm til at fastslå, hvad der kan udfyldes automatisk."</string>
    <string name="credman_autofill_confirmation_message" msgid="843829628024668466">"&lt;b&gt;Brug &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Fra nu af gemmes nye adgangskoder, adgangsnøgler og andre oplysninger her. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; kan bruge, hvad der er på din skærm, til at vurdere, hvad der kan udfyldes automatisk."</string>
    <string name="credman_picker_title" msgid="8191267620665129205">"Adgangskoder, adgangsnøgler og datatjenester"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Vil du deaktivere %1$s?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Vil du deaktivere denne tjeneste?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Gemte oplysninger som f.eks. adgangskoder, adgangsnøgler, betalingsmetoder og andre oplysninger udfyldes ikke, når du logger ind. Hvis du vil bruge dine gemte oplysninger, skal du vælge en adgangskode, en adgangsnøgle eller en datatjeneste."</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Vil du bruge %1$s?"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s bruger det, der vises på din skærm, til at afgøre, hvad der kan udfyldes automatisk."</string>
    <string name="credman_error_message_title" msgid="4099557206946333568">"Grænse for antal adgangskoder, adgangsnøgler og datatjenester"</string>
    <string name="credman_error_message" msgid="8334797097200415449">"Du kan have op til 5 aktive adgangskoder, adgangsnøgler og datatjenester ad gangen. Deaktiver en tjeneste, hvis du vil tilføje en ny."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Deaktiver"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Autofyld"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Logningsniveau"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Maks. antal anmodninger pr. session"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Højeste antal synlige datasæt"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Nulstil til standardværdierne"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Udviklerindstillingerne for autofyld blev nulstillet"</string>
    <string name="location_category" msgid="3496759112306219062">"Lokation"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Lokationsindikator i statusbjælke"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Vis i forbindelse med alle lokationer, herunder netværk og forbindelse"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Gennemtving fuld GNSS-måling"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Registrer alle GNSS-konstellationer og -frekvenser uden opgavegennemløb"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Indtastningsmetode"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Indtastning med styluspen"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Når den aktuelle indtastningsmetode er aktiveret, registreres MotionEvent fra en styluspen, hvis en editor er fokuseret."</string>
    <string name="device_theme" msgid="5027604586494772471">"Enhedstema"</string>
    <string name="default_theme" msgid="4815428567082263639">"Standard"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Netværksnavn"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Vis netværksnavn på statusbjælken"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Instant-app"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Slå Lageradministrator fra?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Opdater Forstyr ikke"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Sæt notifikationer på pause, så du kan koncentrere dig"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funktionen er ikke tilgængelig"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Denne funktion er blevet deaktiveret, fordi den gør din telefon langsom"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Vis altid dialogboks med nedbrud"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Vis dialogboks, hver gang en app går ned"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Vælg ANGLE-aktiveret app"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Der er ikke angivet nogen ANGLE-aktiveret app"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"ANGLE-aktiveret app: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Indstillinger for grafikdriver"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Skift indstillingerne for grafikdriver"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Når der er flere grafikdrivere, kan du vælge at bruge den opdaterede grafikdriver til apps, der er installeret på enheden."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Aktivér for alle apps"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Vælg grafikdriver"</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">"Udviklerdriver"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Grafikdriver til system"</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="4648827560023949786">"Eksperimentel: Aktivér ANGLE"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="2170215556348477481">"Advarsel! Aktivér ANGLE som OpenGL ES-standarddriver. Denne funktion er under udvikling og er muligvis ikke kompatibel med visse kamera- og videoapps."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"Du skal genstarte for at ændre OpenGL ES-systemdriveren"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Ændringer i appkompatibilitet"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Skift appens kompatibilitetsændringer"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Ændringer i standardvalg for aktiveret"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Ændringer i standardvalg for deaktiveret"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Det er kun apps med fejlretningsmuligheder, som kan få ændret appkompatibiliteten. Installer en app med fejlretningsmuligheder, og prøv igen."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Er afhængig af en anden indstilling"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Konto"</string>
    <string name="my_device_info_account_preference_summary" msgid="3510582677937510545">"%d konti"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Enhedens navn"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Grundlæggende oplysninger"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Juridiske og lovmæssige oplysninger"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Enhedsoplysninger"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Enheds-id\'er"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Styring af Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Giv appen tilladelse til at styre Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Giv denne app tilladelse til at aktivere og deaktivere Wi-Fi, søge efter og oprette forbindelse til Wi-Fi-netværk, tilføje og fjerne netværk eller starte et lokalt hotspot"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Åbn via NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Giv appen tilladelse til at åbne, når der scannes et NFC-tag"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Giv appen tilladelse til at åbne, når der scannes et NFC-tag.\nHvis denne tilladelse er aktiveret, kan appen vælges, når der registreres et tag."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Afspil medier på"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Afspil <xliff:g id="LABEL">%s</xliff:g> på"</string>
    <string name="media_output_title_without_playing" msgid="3339321669132875821">"Lyden afspilles på"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Denne enhed"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Enheden kan ikke bruges under opkald"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Besvar opkald på"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Dette adgangspunkt kan ikke ændres."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Deaktiver ringetoner"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Tryk på afbryderknappen og Lydstyrke op på samme tid for at"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Genvej til at stoppe ringelyd"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibrere"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Slå lyden fra"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibrer"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Slå lyden fra"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Hvis du vil aktivere funktionen, skal du først ændre \"Hold afbryderknappen nede\" til menuen for afbryderknappen."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Netværksoplysninger"</string>
    <string name="devices_title" msgid="649715719278562515">"Enheder"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Vælg netværk"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Afbrudt"</string>
    <string name="network_connected" msgid="7637745547242487795">"Forbundet"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Opretter forbindelse…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Der kunne ikke oprettes forbindelse"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Der blev ikke fundet nogen netværk."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Der blev ikke fundet nogen netværk. Prøv igen."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(forbudt)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Intet SIM-kort"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Ingen"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Du skal bruge et SIM-kort for at oprette forbindelse"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Du skal bruge et SIM-kort fra <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> for at oprette forbindelse"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Foretrukken netværkstilstand: WCDMA foretrækkes"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Foretrukken netværkstilstand: Kun GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Foretrukken netværkstilstand: Kun WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Foretrukken netværkstilstand: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Foretrukken netværkstilstand: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Foretrukken netværkstilstand: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Foretrukken netværkstilstand: Kun CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Foretrukken netværkstilstand: Kun EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Foretrukken netværkstilstand: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Foretrukken netværkstilstand: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Foretrukken netværkstilstand: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Foretrukken netværkstilstand: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Foretrukken netværkstilstand: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Foretrukken netværkstilstand: Global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Foretrukken netværkstilstand: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Foretrukket netværkstilstand: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Foretrukken netværkstilstand: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Foretrukken netværkstilstand: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Foretrukken netværkstilstand: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Foretrukken netværkstilstand: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Foretrukken netværkstilstand: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Foretrukken netværkstilstand: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Foretrukken netværkstilstand: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Foretrukken netværkstilstand: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Foretrukken netværkstilstand: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Foretrukken netværkstilstand: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Foretrukken netværkstilstand: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Foretrukken netværkstilstand: Kun NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Foretrukken netværkstilstand: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Foretrukken netværkstilstand: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Foretrukken netværkstilstand: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Foretrukken netværkstilstand: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Foretrukken netværkstilstand: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Foretrukken netværkstilstand: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Foretrukken netværkstilstand: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Foretrukken netværkstilstand: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Foretrukken netværkstilstand: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Foretrukken netværkstilstand: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (anbefalet)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (anbefalet)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (anbefalet)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Vælg netværk automatisk"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Indst. for mobilselskab"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Konfiguration af datatjeneste"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobildata"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Brug data via mobilnetværk"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefonen skifter automatisk til dette mobilselskab, når netværket er inden for rækkevidde"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Der er ikke et tilgængeligt SIM-kort"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Opkaldspræference"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Sms-præference"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Spørg hver gang"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Tilføj et netværk"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Standard til opkald"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Standard til sms"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Standard til opkald og sms"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Standard til mobildata"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Mobildata er aktiveret"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobildata er deaktiveret"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Tilgængeligt"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Tilføj SIM-kort"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktiv/knyttet til SIM-kort"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Inaktiv/knyttet til SIM-kort"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Aktivt/eSIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Inaktivt/eSIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Navn på SIM-kort og farve"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Navn"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Farve (anvendes af kompatible apps)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Gem"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Brug SIM-kort"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Fra"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Fjern SIM-kortet for at deaktivere det"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Tryk for at aktivere <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Ryd SIM-kort"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Foretrukken netværkstype"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Skift driftstilstand for netværket"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Foretrukken netværkstype"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Version af indstillinger for mobilselskab"</string>
    <string name="call_category" msgid="641461844504128789">"Opkald"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Videoopkald via mobilnetværk"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Systemvalg"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Skift CDMA-roamingtilstand"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Systemvalg"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Netværk"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA-abonnement"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Skift mellem RUIM/SIM og NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"abonnement"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Automatisk registrering…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Vil du tillade dataroaming?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Kontakt din netværksudbyder for at få oplyst priser."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Dataforbrug i apps"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Ugyldig netværkstilstand <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignorer."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Adgangspunkter"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"apn"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Utilgængelig ved forbindelse til <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Se mere"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Vil du aktivere <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Vil du aktivere SIM-kortet?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Vil du skifte til <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Vil du skifte til at bruge SIM-kort?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Vil du bruge <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Der kan kun være ét aktivt SIM-kort ad gangen.\n\nSelvom du skifter til <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, opsiges din tjeneste fra <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g> ikke."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="8977951796005849471">"Der kan kun være 1 aktivt eSIM ad gangen.\n\nDin <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>-tjeneste opsiges ikke, hvisdu skifter til <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Der kan kun være ét aktivt SIM-kort ad gangen.\n\nSelvom du skifter SIM-kort, opsiges din tjeneste fra <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> ikke."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Du kan ikke bruge 2 SIM-kort ad gangen. Hvis du vil bruge <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, skal du deaktivere et andet SIM-kort."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Skift til <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_carrier_list_item_for_turning_off" msgid="5392037608705799522">"Deaktiver <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Din tjeneste deaktiveres ikke, når du deaktiverer SIM-kortet"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Opretter forbindelse til netværket…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Skifter til <xliff:g id="CARRIER_NAME">%1$s</xliff:g> til opkald og beskeder…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Det lykkedes ikke at skifte mobilselskab"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Det lykkedes ikke at skifte mobilselskab på grund af en fejl."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Vil du deaktivere <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Vil du deaktivere SIM-kortet?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Deaktiverer SIM-kort<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Mobilselskabet kunne ikke deaktiveres"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Noget gik galt, og dit mobilselskab kunne ikke deaktiveres."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Vil du bruge to SIM-kort?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Denne enhed kan have to aktive SIM-kort på samme tid. Hvis du vil fortsætte med kun at bruge ét SIM-kort ad gangen, kan du trykke på \"Nej tak\"."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Vil du genstarte enheden?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Ja"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Genstart"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Nej tak"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Annuller"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Skift"</string>
    <string name="sim_action_turn_off" msgid="3506698692916473000">"Deaktiver"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"SIM-kortet kunne ikke aktiveres"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Prøv at aktivere SIM-kortet igen. Genstart enheden, hvis problemet fortsætter."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Netværksaktivering"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Nyt mobilselskab"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> er aktiv"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Tryk for at opdatere indstillingerne for SIM-kort"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Skiftet til <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Der er skiftet til et andet mobilselskab"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Dit mobilnetværk er ændret"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Konfigurer dit andet SIM-kort"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Vælg dit aktive SIM-kort, eller brug to SIM-kort samtidigt"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Vælg et nummer, du vil bruge"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{Der er 1 tilgængeligt nummer på denne enhed, men der kan kun bruges ét ad gangen}=2{Der er 2 tilgængelige numre på denne enhed, men der kan kun bruges ét ad gangen}one{Der er # tilgængeligt nummer på denne enhed, men der kan kun bruges ét ad gangen}other{Der er # tilgængelige numre på denne enhed, men der kan kun bruges ét ad gangen}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Aktiverer<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"Aktiveringen kan ikke gennemføres lige nu"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Vil du bruge <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> anvendes til mobildata, opkald og sms-beskeder."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Der er ingen tilgængelige aktive SIM-kort"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Hvis du senere vil bruge mobildata, opkaldsfunktioner og sms, kan du gå til dine netværksindstillinger"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM-kort"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Vil du rydde dette eSIM?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Hvis du rydder dette SIM-kort, fjernes tjenesten fra <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> på denne enhed.\n\nTjenesten fra <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> opsiges ikke."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Ryd"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Rydder SIM-kort…"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"SIM-kortet kan ikke ryddes"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"Dette SIM-kort kan ikke ryddes på grund af en fejl.\n\nGenstart din enhed, og prøv igen."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Opret forbindelse til enheden"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Appen <xliff:g id="APPNAME">%1$s</xliff:g> vil gerne have midlertidig adgang til dit Wi-Fi-netværk for at oprette forbindelse til din enhed"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Der blev ikke fundet nogen enheder. Sørg for, at enhederne er tændt, og at der kan oprettes forbindelse til dem."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Prøv igen"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Der opstod et problem Appen har annulleret anmodningen om at vælge en enhed."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Der blev oprettet forbindelse"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Forbindelsen mislykkedes"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Vis alle"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Søger efter enhed…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Opretter forbindelse til enhed…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Venstre"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Højre"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Etui"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Indstillingspanel"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Gennemtving skrivebordstilstand"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Gennemtving eksperimentel skrivebordstilstand på sekundære skærme"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Aktivér app, hvis størrelse ikke kan justeres, i multivindue"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Tillader, at apps, hvis størrelse ikke kan justeres, kan være i et multivindue"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Tilsidesæt force-dark"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Tilsidesætter funktionen force-dark og anvender Altid aktiveret"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privatliv"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Tilladelser, kontoaktivitet, personoplysninger"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Styringselementer"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Fjern"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Behold"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Vil du fjerne dette forslag?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Begrænset lagerplads. <xliff:g id="PERCENTAGE">%1$s</xliff:g> anvendt – <xliff:g id="FREE_SPACE">%2$s</xliff:g> ledig"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Send feedback"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Vil du give os feedback om dette forslag?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> blev kopieret til udklipsholderen."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Brug af hjælpefunktioner"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 app har fuld adgang til din enhed}one{# app har fuld adgang til din enhed}other{# apps har fuld adgang til din enhed}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Vigtige oplysninger"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"FORTSÆT"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NEJ TAK"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Lokation"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Dit mobilselskab registrerer muligvis din lokation, når du bruger denne tjeneste til nødopkald.\n\nGå til dit mobilselskabs privatlivspolitik for at få flere oplysninger."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Du kan miste adgangen til resterende tid eller data. Kontakt din udbyder, før du fjerner det."</string>
    <string name="content_capture" msgid="868372905432812238">"Appindhold"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Giv apps tilladelse til at sende indhold til Android-systemet"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Registrer systemets heap dump"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Memory Tagging Extension"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Memory Tagging Extension (MTE) gør det nemmere at finde sikkerhedsproblemer med hukommelsen i din app og gør indlejret kode i appen mere sikker."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Aktivering af MTE kan gøre din enhed langsommere."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Få flere oplysninger om MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Aktivér MTE, indtil du deaktiverer den"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Genstart din enhed for at aktivere MTE."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Genstart din enhed for at deaktivere MTE."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Aktivér MTE for en enkelt session"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Systemet genstarter og tillader, at der eksperimenteres med Memory Tagging Extension (MTE). MTE kan forringe systemets ydeevne og stabilitet. Indstillingen nulstilles ved næste genstart."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Genstart for en enkelt session med MTE er aktiveret"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"MTE er allerede aktiveret"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Registrering af systemets heap dump"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Systemets heap dump kunne ikke registreres"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Registrer automatisk systemets heap dumps"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Registrer automatisk en heap dump for Android-systemet, når det anvender for meget hukommelse"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Afbryd forbindelsen"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Nødopkald"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Nødopkald via Wi‑Fi-opkald understøttes ikke af dit mobilselskab.\nEnheden skifter automatisk til et mobilnetværk for at foretage et nødopkald.\nDer kan kun foretages nødopkald i områder med mobilnetværksdækning."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Brug Wi‑Fi til opkald for at få en bedre kvalitet"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Indgående mms-besked"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Mms-beskeden kan ikke sendes"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Tryk for at tillade mms-beskeder via <xliff:g id="OPERATOR_NAME">%1$s</xliff:g>, når mobildata er slået fra"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"Mms-besked"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Der er et problem med SIM-kombinationen"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Funktionaliteten kan blive begrænset, hvis du bruger <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g>. Tryk for at få flere oplysninger."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"SIM-kombination"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Oplysninger om din arbejdspolitik"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Indstillinger, som administreres af din it-administrator"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"Grafikprocessor"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Håndtering af fejlrapport"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Afgør, hvilken app der håndterer genvejen til fejlrapporten på din enhed."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Personlig"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Arbejde"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Systemstandard"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Ingen"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Dette valg er ikke længere gyldigt. Prøv igen."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Hold afbryder­knappen nede"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Hold afbryderknappen nede for at tilgå"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Menu for afbryderknappen"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Digital assistent"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Tilgå digital assistent"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Tilgå menuen for afbryderknappen"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Du skal først konfigurere en skærmlås"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Menu for afbryderknappen:\nHold afbryderknappen og Lydstyrke op inde på samme tid"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Deaktiver ringetoner:\nTryk på en lydstyrkeknap for at bruge genvejen"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Tryklængde"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Juster følsomheden ved at vælge, hvor lang tid afbryderknappen skal holdes inde"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Kort"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Langt"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Vis Wallet"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Tillad adgang til Wallet via låseskærmen"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Vis QR-kodescanneren"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Giv adgang til QR-kodescanneren via låseskærmen"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Vis enhedsstyring"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Fra låseskærmen"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Brug enhedsstyring"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Du skal først aktivere \"Vis enhedsstyring\"."</string>
    <string name="lockscreen_double_line_clock_summary" msgid="4109235686687860393">"Størrelsen på uret ændrer sig baseret på indhold på låseskærmen"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Dynamisk ur"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Genveje"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="one"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$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">"Vil du deaktivere VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Dette deaktiverer også din 5G-forbindelse.\nNår du er i et opkald, kan du ikke bruge internettet, og nogle apps fungerer muligvis ikke."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Suspender udførelse for cachelagrede apps"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Udløber aldrig."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Rettigheden udløber aldrig."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Tillad overlejring af skærme fra Indstillinger"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Giv apps, som kan vises over andre apps, tilladelse til at overlejre skærme fra appen Indstillinger"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Tillad imiteret modem"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Tillad, at denne enhed anvender tjenesten til imitation af modem til instrumenteringstest. Undlad at aktivere dette under normal brug af telefonen"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Medier"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Fastgør medieafspiller"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Medieafspilleren forbliver åben i Kvikmenu, så du hurtigt kan genoptage afspilningen"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Vis medier på låseskærmen"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Medieafspilleren forbliver åben på låseskærmen, så du hurtigt kan genoptage afspilningen"</string>
    <string name="media_controls_recommendations_title" msgid="3012692549413927608">"Vis Assistent-medieanbefalinger"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Baseret på din aktivitet"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Skjul afspiller"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Vis afspiller"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"Medier"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth aktiveres"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM-kort"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Opkald og sms-beskeder"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Wi-Fi-opkald"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Foretag og modtag opkald via Wi-Fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Opkald"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"Sms"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"foretrækkes"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"foretrukket til opkald"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"foretrukket til sms"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"ikke tilgængelig"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Midlertidigt utilgængelig"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Intet SIM-kort"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Netværkspræferencer"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"netværksforbindelse, internet, trådløs, data, wifi, wi-fi, mobilnetværk, mobil, mobilselskab, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Vil du nulstille dit internet?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Nulstiller dit internet…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Løs problem med forbindelsen"</string>
    <string name="networks_available" msgid="3299512933684383474">"Tilgængelige netværk"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Afbryd ethernetforbindelsen for at skifte netværk"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"W+-forbindelser"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Tillad, at Google Fi bruger W+-netværk for at øge hastigheden og dækningen"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"W+-netværk"</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">"eSIM"</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 til <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"opkald"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"sms"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"mobildata"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"For at forbedre brugeroplevelsen på enheden kan apps og tjenester stadig til enhver tid scanne efter Wi‑Fi-netværk, også selvom Wi-Fi er deaktiveret. Dette kan f.eks. bruges til at forbedre lokationsbaserede funktioner og tjenester. Du kan ændre dette i indstillingerne for Wi-Fi-scanning."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Skift"</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">"Forbundet"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Midlertidigt forbundet"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Anvender <xliff:g id="SUBNAME">%1$s</xliff:g> midlertidigt"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Der er ingen forbindelse"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Ingen automatisk mobildataforbindelse"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Vil du deaktivere mobildata?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Du vil ikke have data- eller internetadgang via <xliff:g id="CARRIER">%s</xliff:g>. Der vil kun være adgang til internettet via Wi-Fi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"dit mobilselskab"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Tillades ikke af din organisation"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Ikke tilgængelig, da sengetidstilstand er aktiveret"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Vigtigheden af notifikationer blev nulstillet."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Apps"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"En enhed vil gerne have adgang til dine beskeder. Tryk for at få flere oplysninger."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Vil du give adgang til beskeder?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"En Bluetooth-enhed, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, vil gerne have adgang til dine beskeder.\n\nDu har ikke oprettet forbindelse til <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> før."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"En enhed vil gerne have adgang til dine kontakter og din opkaldshistorik. Tryk for at få flere oplysninger."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Vil du give adgang til kontakter og opkaldshistorik?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"En Bluetooth-enhed, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, vil gerne have adgang til dine kontakter og din opkaldshistorik. Dette omfatter data om indgående og udgående opkald.\n\nDu har ikke oprettet forbindelse til <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> før."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Lysstyrke"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Låseskærm"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Udseende"</string>
    <string name="category_name_color" msgid="937514550918977151">"Farve"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Andre skærmindstillinger"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Generelt"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Brug Mørkt tema"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Brug Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Brug Deaktiver ringetoner"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Brug Wi-Fi-hotspot"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Brug appfastgørelse"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Brug Indstillinger for udviklere"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Brug en udskrivningstjeneste"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Tillad flere brugere"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"tillad, flere, brugere, mange"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Brug trådløs fejlretning"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Brug Indstillinger for grafikdriver"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Brug Nattelys"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Brug NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Brug automatisk lysstyrke"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Brug Wi-Fi-opkald"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Se alle apps"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Intelligent viderestilling"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Intelligent viderestilling er aktiveret"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Intelligent viderestilling er deaktiveret"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Indstillinger for opkald"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Opdaterer indstillinger..."</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Fejl i indstillinger for opkald."</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Fejl med netværk eller SIM-kort"</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"SIM-kortet er ikke aktiveret."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Angiv telefonnumre"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Angiv telefonnummer"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Telefonnummeret mangler."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"OK"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Tillad 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G er mindre sikkert, men forbedrer muligvis din forbindelse på visse lokationer. 2G er altid tilladt til brug ved nødopkald."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> kræver, at 2G er tilgængeligt"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Kræv kryptering"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Kryptering øger sikkerheden, men du kan muligvis ikke ringe op på visse lokationer. Kryptering er aldrig opkrævet ved nødopkald"</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Alle tjenester"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Vis adgang til udklipsholder"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Vis en meddelelse, når apps får adgang til tekst, billeder eller andet indhold, du har kopieret"</string>
    <string name="all_apps" msgid="3054120149509114789">"Alle apps"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Tillad ikke"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultrabredbånd (UWB, Ultra-Wideband)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Hjælper med at identificere den relative position af enheder i nærheden, som har UWB"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Deaktiver flytilstand for at bruge UWB"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB er ikke tilgængelig på den nuværende lokation"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Kameraadgang"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Mikrofonadgang"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"For apps og tjenester"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"For apps og tjenester. Hvis denne indstilling er deaktiveret, deles mikrofondata muligvis stadig, når du ringer til et alarmnummer."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Forrige"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Næste"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Forhåndsvisning af farve"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Anmodning om SIM-adgang"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"En enhed anmoder om adgang til dit SIM-kort. Tryk for at få flere oplysninger."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Vil du give adgang til SIM-kortet?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"En Bluetooth-enhed, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, anmoder om adgang til data på dit SIM-kort. Dette omfatter dine kontakter.\n\nNår der er oprettet forbindelse, vil <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> modtage alle indgående opkald til <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"En Bluetooth-enhed er tilgængelig"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"En enhed vil gerne oprette forbindelse. Tryk for at få flere oplysninger."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Vil du oprette forbindelse til Bluetooth-enheden?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> vil gerne oprette forbindelse til denne telefon.\n\nDu har ikke tidligere oprettet forbindelse til <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Opret ikke forbindelse"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Opret forbindelse"</string>
    <string name="tare_settings" msgid="3788654800004869077">"TARE-indstillinger"</string>
    <string name="tare_on" msgid="2386073225978684535">"Til"</string>
    <string name="tare_off" msgid="6305694402929756726">"Fra"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Gendan standardindstillingerne"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Standardindstillingerne blev gendannet."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Maksimal balance ved fuld opladning"</string>
    <string name="tare_balances" msgid="731881382594747961">"Saldi"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Grænser for forbrug"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Grænse for indledende forbrug"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Minimumsgrænse for forbrug"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Maksimumsgrænse for forbrug"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modifikatorer"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Handlinger (udførelsesomkostninger)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Handlinger (basispris)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Bonusser pr. forekomst af en hændelse"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Belønninger/sek. i begivenhedens varighed"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Maksimalt antal bonusser om dagen"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Appinstallation"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Topaktivitet"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Notifikationen blev set"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Notifikationen blev set inden for 15 min."</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Interaktion med notifikation"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Interaktion med widget"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Anden brugerinteraktion"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Job med maksimal prioritet starter"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Job med maksimal prioritet kører"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Job med høj prioritet starter"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Job med høj prioritet kører"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Job med standardprioritet starter"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Job med standardprioritet kører"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Job med lav prioritet starter"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Job med lav prioritet kører"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Job med minimal prioritet starter"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Job med minimal prioritet kører"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Timeout-justering for job"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Minimumssaldo for fuld opladning (undtagelse)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Minimumssaldo for fuld opladning (systemapp uden grafisk brugerflade)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Minimumssaldo for fuld opladning (øvrige apps)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Tilføjelse til minimumssaldo ved fuld opladning (platforme til appopdatering)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Opladning"</item>
    <item msgid="658627268149681677">"Hvil"</item>
    <item msgid="1599558140284643834">"Strømsparetilstand"</item>
    <item msgid="588427840913221601">"Procestilstand"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Bekræft"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Se forhåndsvisning"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Vælg en pauseskærm"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Se yderligere oplysninger"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Se f.eks. klokkeslættet, vejret eller andre oplysninger på pauseskærmen"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Vis styring af smartenheder"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Vis knappen til styring af smartenheder fra pauseskærmen"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Flere indstillinger"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Vælg din pauseskærm"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Vælg, hvad der skal vises på din skærm, når din tablet sidder i dockingstationen. Din enhed bruger muligvis mere batteri, når der anvendes en pauseskærm."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Tilpas"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Tilpas <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Du skal genstarte for at aktivere understøttelse af freeform."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Du skal genstarte for at gennemtvinge aktivering af computertilstand på sekundære skærme."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Genstart nu"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Genstart senere"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Rumlig lyd"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Lyden fra kompatible medieenheder bliver endnu bedre"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Registrering af hovedbevægelser"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Lyden ændrer sig, når du bevæger dit hoved, for at opnå en mere naturlig lyd"</string>
    <string name="bluetooth_details_permissions_sync_title" msgid="7277580382321003521">"Synkroniser tilladelser fra telefonen"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="8125037984381432059">"Giv dit ur de samme apptilladelser, som denne telefon har"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Type af lydenhed"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"Ukendt"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Højttaler"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Høretelefoner"</string>
    <string name="bluetooth_details_audio_device_type_hearing_aid" msgid="1310631131071939859">"Høreapparat"</string>
    <string name="bluetooth_details_audio_device_type_carkit" msgid="4439017600454703229">"Bilsæt"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Andet"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Grænse for downloadhastighed på netværket"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Konfigurer grænsen for indgående båndbredde på netværket, som vil gælde for alle netværk, der leverer internetforbindelse."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Konfigurer grænsen for downloadhastighed på netværket"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Ubegrænset"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Deaktiver begrænsningerne for underprocesser"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Deaktiver begrænsningerne for brugen af systemets ressourcer på underprocesser i appen"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Gennemtving aktivering af rollen notetagning"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Aktivér systemintegrationer til notetagning via rollen notetagning. Hvis rollen notetagning allerede er aktiveret, sker der ikke noget. Kræver genstart."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Udsendelse"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Udsend <xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Lyt til udsendelser, der afspilles i nærheden"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Udsend medier til enheder i nærheden, eller lyt til andres udsendelser"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Udsendelser"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Lytter til"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Find udsendelser"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Forlad udsendelse"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Scan QR-kode"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Angiv adgangskode"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Der kan ikke oprettes forbindelse. Prøv igen."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Forkert adgangskode"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Kan ikke deltage i udsendelsen"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Centrer QR-koden nedenfor for at gå i gang med at lytte"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"QR-koden har ikke et gyldigt format"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Konverter til eSIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Overfør eSIM til en anden enhed"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# app}one{# app}other{# apps}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Apps installeret i baggrunden"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Din enhedsproducent kan installere apps på din enhed i baggrunden eller tillade, at dit mobilselskab eller andre partnere gør dette.\n\nApps, der er angivet her, er ikke påkrævet for, at din enhed fungerer normalt. Du kan afinstallere apps, du ikke vil have."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Der er ingen apps installeret i baggrunden"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Afinstaller app"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Apps installeret i den seneste måned}one{Apps installeret i de seneste}other{Apps installeret i de seneste # måneder}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Apps, som er installeret for mere end # måned siden}one{Apps, som er installeret for mere end # måned siden}other{Apps, som er installeret for mere end # måneder siden}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Billedformat"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Prøv et nyt billedformat for at se denne app, hvis den ikke er designet til at vises korrekt på din <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Prøv et nyt billedformat for at se denne app, hvis den ikke er designet til at vises korrekt på din <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Visse apps er muligvis ikke optimeret til bestemte billedformater."</string>
    <string name="aspect_ratio_summary_text" msgid="4737461467467220325">"Prøv et nyt billedformat for at se en app, hvis den ikke er designet til at vises korrekt på din <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary_text" msgid="5544816872094235840">"Prøv et nyt billedformat for at se en app, hvis den ikke er designet til at vises korrekt på din <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Visse apps er muligvis ikke optimeret til bestemte billedformater."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Foreslåede apps"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Ændrede apps"</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"Standardindstilling for appen"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Fuld skærm"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Halv skærm"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Billedformat på enheden"</string>
    <string name="user_aspect_ratio_16_9" msgid="2286644872775170164">"16:9"</string>
    <string name="user_aspect_ratio_3_2" msgid="199262962518318932">"3:2"</string>
    <string name="user_aspect_ratio_4_3" msgid="5196232982878982220">"4:3"</string>
    <string name="user_aspect_ratio_option_a11y" msgid="1235801996029095219">"<xliff:g id="NUMERATOR">%1$s</xliff:g>:<xliff:g id="DENOMINATOR">%2$s</xliff:g>"</string>
    <string name="app_aspect_ratio_footer" msgid="4029509301182067475">"Denne app genstartes, når du ændrer billedformatet. Du mister muligvis ændringer, der ikke er gemt. Visse apps er muligvis ikke optimeret til bestemte billedformater."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Billedformat (eksperimentel)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Billedformat (eksperiment)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Billedformat (labs)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"Eksperimentel"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Eksperiment"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Labs"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Fingeraftrykssensor"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Lysnotifikationer"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Om lysnotifikationer"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Fra"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Til/Kameralys"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Til/Skærmlys"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Til/Skærmlys og kameralys"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Blink med kameraets eller skærmens lys, når du modtager en notifikation, eller en alarm går i gang"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Blink med skærmens lys, når du modtager notifikationer, eller en alarm går i gang"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Vær forsigtig med at bruge lysnotifikationer, hvis du er lysfølsom"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"lysnotifikation, lys, hørehæmmet, høreskadet"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Forhåndsvisning"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Kameralys"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Skærmlys"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Farve på skærmlys"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Blå"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Azurblå"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Grønblå"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Forårsgrøn"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Grøn"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Chartreusefarvet"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Gul"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Orange"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Rød"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Rose"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Magenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Violet"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Udfør"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Annuller"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Middel"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Høj"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Denne app kan kun åbnes i 1 vindue"</string>
    <string name="generic_accessibility_service_on" msgid="4466229372357726824">"Til"</string>
    <string name="generic_accessibility_service_off" msgid="4759859497651675724">"Fra"</string>
    <string name="generic_accessibility_feature_shortcut_off" msgid="4022872394514077907">"Fra"</string>
    <string name="accessibility_shortcut_state_off" msgid="8158137799007601475">"Fra"</string>
    <string name="daltonizer_state_on" msgid="131013270022603983">"Til"</string>
    <string name="daltonizer_state_off" msgid="1162285688069856179">"Fra"</string>
    <string name="color_inversion_state_on" msgid="1160969033636440368">"Til"</string>
    <string name="color_inversion_state_off" msgid="6925638668080451724">"Fra"</string>
    <string name="color_inversion_feature_summary" msgid="1199876648549627647">"Gør lyse skærme mørke og mørke skærme lyse"</string>
    <string name="magnification_feature_summary" msgid="2053971569640663564">"Zoom ind på skærmen"</string>
    <string name="autoclick_disabled" msgid="3213396804955002120">"Fra"</string>
    <string name="show_captions_disabled" msgid="690650956523818755">"Fra"</string>
    <string name="show_captions_enabled" msgid="7089043007924626">"Til"</string>
    <string name="live_caption_disabled" msgid="3562035026547887366">"Fra"</string>
    <string name="live_caption_enabled" msgid="5269360946200718949">"Til"</string>
    <string name="about_phone_device_name_warning" msgid="3243226572404472381">"Din enheds navn er synligt for apps, du har installeret. Det kan muligvis også ses af andre, når du opretter forbindelse til Bluetooth-enheder eller et Wi-Fi-netværk, eller når du konfigurerer et Wi-Fi-hotspot."</string>
    <string name="grammatical_gender_title" msgid="8584242850477270828">"Grammatisk køn"</string>
    <string name="grammatical_gender_dialog_title" msgid="8754048592099871587">"Vælg grammatisk køn"</string>
    <string name="content_protection_preference_title" msgid="5069260032659193074">"Scanning af vildledende apps"</string>
    <string name="content_protection_preference_summary" msgid="2252393849408445391">"Tjek appaktivitet for phishing"</string>
    <string name="content_protection_preference_user_consent_switch_title" msgid="1797782616799594426">"Brug scanning til at registrere vildledende apps"</string>
    <string name="content_protection_preference_user_consent_work_profile_switch_title" msgid="3004347470520916069">"Brug scanning til at registrere vildledende arbejdsapps"</string>
    <string name="content_protection_preference_subpage_summary" msgid="3595621220981703364"></string>
    <string name="content_protection_preference_subpage_info" msgid="6890886357653365489"></string>
</resources>
