<?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">"Nei"</string>
    <string name="create" msgid="986997212165228751">"Opprett"</string>
    <string name="allow" msgid="3763244945363657722">"Tillat"</string>
    <string name="deny" msgid="7326117222944479942">"Avslå"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Slå på"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Ukjent"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Trykk for å vise informasjon"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Du er nå # trinn fra å bli en utvikler.}other{Du er nå # trinn fra å bli en utvikler.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Du er nå utvikler!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Det trengs ikke, du er allerede utvikler."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Slå på utvikleralternativer først."</string>
    <string name="header_category_system" msgid="1665516346845259058">"System"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Fungerer som normalt"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Ute av drift"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio er av"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roamer"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Ingen roaming"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Frakoblet"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Kobler til"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Tilkoblet"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Satt på vent"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Ukjent"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Forhåndsvisning"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Gjør mindre"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Gjør større"</string>
    <string name="stay_awake_on_fold_title" msgid="6590454679898134221">"Alltid"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"Den ytre skjermen slås på når du legger sammen enheten"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Bare spill, videoer med mer"</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"Den ytre skjermen slås på for apper som hindrer skjermen fra å bli inaktiv"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Aldri"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"Den ytre skjermen låses når du legger sammen enheten"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Bruk automatisk rotasjon"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Ansiktsgjenkjenning bruker frontkameraet til å forbedre nøyaktigheten til automatisk rotasjon. Bilder blir aldri lagret eller sendt til Google."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Synlig for alle Bluetooth-enheter i nærheten (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Synlig for alle Bluetooth-enheter i nærheten"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Ikke synlig for andre Bluetooth-enheter"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Synlig bare for sammenkoblede enheter"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Bluetooth-enheter"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Enhetsnavn"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Gi denne enheten nytt navn"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Gi nytt navn"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Koble fra enhet?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Koble til en ny enhet"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"Bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Tilkoble høyre øre"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Tilkoble venstre øre"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Tilkoble det andre øret"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Det venstre høreapparatet ditt er tilkoblet.\n\nFor å koble til det høyre høreapparatet må du sørge for at det er slått på og klart for tilkobling."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Det høyre høreapparatet ditt er tilkoblet.\n\nFor å koble til det venstre høreapparatet må du sørge for at det er slått på og klart for tilkobling."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Tilkoble høyre øre"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Tilkoble venstre øre"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"For alle tilgjengelige høreenheter"</string>
    <string name="bluetooth_device_controls_title" msgid="1895676556354697234">"Innstillinger for høreapparater"</string>
    <string name="bluetooth_device_controls_summary" msgid="8115767735418425663">"Snarvei, kompatibilitet med høreapparater"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"For denne enheten"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Utenhet for lyd"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Om lyd"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Send lyder til høreapparatet eller telefonhøyttaleren"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Relaterte"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Ringelyd og alarmer"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Lyd i samtaler"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Medier"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Varsler og andre systemlyder"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Som standard blir lydutgangen valgt av enkeltapper"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Bluetooth-enhet uten navn"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Søker"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Finner ingen Bluetooth-enheter."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Forespørsel om Bluetooth-sammenkobling"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Tilkoblingsforespørsel"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Trykk for å koble sammen med <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth er av"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Trykk for å slå det på"</string>
    <string name="device_picker" msgid="2427027896389445414">"Velg Bluetooth-enhet"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> ønsker å slå på Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> ønsker å slå av Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"En app ønsker å slå på Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"En app ønsker å slå på Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Slår på Bluetooth …"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Slår av Bluetooth …"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Bluetooth-tilkoblingsforespørsel"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Forespørsel om tilgang for telefonbok"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Forespørsel om meldingstilgang"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Synlig som «<xliff:g id="DEVICE_NAME">^1</xliff:g>» for andre enheter"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Slå på Bluetooth for å koble til andre enheter."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Enhetene dine"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Koble til en ny enhet"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Slå av maskinvareavlastning for Bluetooth A2DP"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Slå av maskinvareavlastning for Bluetooth LE-lyd"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Vil du starte enheten på nytt?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Du må starte enheten på nytt for å endre denne innstillingen."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Start på nytt"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Avbryt"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Slå av Bluetooth LE-lyd"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Slår av Bluetooth LE-lydfunksjonen hvis enheten støtter maskinvarefunksjoner for LE-lyd."</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Vis LE-lyd-av/på-bryter i Enhetsdetaljer"</string>
    <string name="bluetooth_enable_leaudio_allow_list" msgid="1692999156437357534">"Slå på tillatelseslisten for Bluetooth LE-lyd"</string>
    <string name="bluetooth_enable_leaudio_allow_list_summary" msgid="725601205276008525">"Slå på funksjonen for tillatelseslisten for Bluetooth LE-lyd."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Medieenheter"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Ringeenheter"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Andre enheter"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Lagrede enheter"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth slås på for å koble til"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Tilkoblingsvalg"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Tidligere tilkoblet"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth er på"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Se alle"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Pekepenn"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Trykk på bakre knapp"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (jobbprofil)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Skriv i tekstfelt"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Ignorer alle knappetrykk på pekepennen"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Pekepenn"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Dato og klokkeslett"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy-tjener"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Tøm"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Port for proxy-tjener"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Ikke bruk proxy-tjener for"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Gjenopprett standardinnstillinger"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Ferdig"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Proxy-tjenerens vertsnavn"</string>
    <string name="proxy_error" msgid="3615905975598084126">"NB"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Angitt vertsnavn er ikke gyldig."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Eksklusjonslisten er ikke riktig formatert. Legg inn en kommadelt liste med ekskluderte domener."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Du må fylle ut portfeltet."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Feltet for portnummer må være tomt om feltet for vertsnavn er tomt."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Angitt port er ikke gyldig."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"HTTP-proxy-tjeneren brukes av nettleseren, men kan ikke brukes av andre apper."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"PAC-nettadresse: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Ping vertsnavn(www.google.no) IPv4:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Test av HTTP-klient:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Kjør ping-test"</string>
    <string name="skip_label" msgid="6380034601349015895">"Hopp over"</string>
    <string name="next_label" msgid="1248293387735652187">"Neste"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Språk"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Rekkefølge for foretrukne språk"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Systemspråk"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Fjern"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Legg til et språk"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Språk"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Foretrukket språk"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Appspråk"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Velg språk for hver app"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Appspråk"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Foreslåtte språk"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Alle språk"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Systemspråk"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Systemstandard"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Språkvalg for denne appen er ikke tilgjengelig fra innstillingene."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Språket kan være forskjellig fra språkene som er tilgjengelige i appen. Noen apper støtter muligens ikke denne innstillingen."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Velg språk for hver app."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Systemet, apper og nettsteder bruker det første språket som støttes, av de foretrukne språkene dine."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"For å velge et språk for hver app, gå til innstillingene for appspråk."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Finn ut mer om appspråk"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Vil du bytte systemspråk til %s?"</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Enhets- og regionsinnstillingene endres."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Endre"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s er ikke tilgjengelig"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Du har latt apper og nettsteder vite at du foretrekker dette språket, men det kan ikke brukes som systemspråk."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Regionsinnstillinger"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Angi innstillinger for enheter og tall"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"La apper bruke regionsinnstillingene dine til å tilpasse opplevelsen din"</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Apper bruker regionsinnstillingene dine når det er mulig."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatur"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Første dag i uken"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Tallpreferanser"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Bruk standardinnstillingen"</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">"Apper som ikke støtter regionsinnstillinger, bruker sine egne standardinnstillinger for lokalitet."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Finn ut mer om språkinnstillinger."</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Vil du fjerne det valgte språket?}other{Vil du fjerne de valgte språkene?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Da vises tekst på et annet språk."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Du kan ikke fjerne alle språkene"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Behold minst ett av de foretrukne språkene"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Ikke tilgjengelig som systemspråk"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Flytt opp"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Flytt ned"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Flytt til toppen"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Flytt nederst"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Fjern språket"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Velg aktivitet"</string>
    <string name="cancel" msgid="5780102414089664898">"Avbryt"</string>
    <string name="okay" msgid="4827099303045669054">"OK"</string>
    <string name="forget" msgid="3754013654135912783">"Glem"</string>
    <string name="save" msgid="3125033126936493822">"Lagre"</string>
    <string name="done" msgid="7497982645646431310">"Ferdig"</string>
    <string name="apply" msgid="7834684883190163536">"Bruk"</string>
    <string name="share" msgid="8502235338607613795">"Del"</string>
    <string name="add" msgid="8335206931421683426">"Legg til"</string>
    <string name="remove" msgid="1028414219245072102">"Fjern"</string>
    <string name="settings_label" msgid="943294133671632976">"Innstillinger"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Innstillinger"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Snarvei for Innstillinger"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Flymodus"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Trådløst og nettverk"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Koble til datatjenester ved roaming"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Koble til datatjenester ved roaming"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Roamingavgifter kan påløpe."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Angi klokkeslettet automatisk"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Angi automatisk"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Posisjon blir brukt til å angi tidssonen når denne av/på-knappen er på"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Bruk lokal standard"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Bruk 24-timers format"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Tid"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Tidsformat"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Tidssone"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Velg tidssone"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Dato"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Søk etter region"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Region"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Velg forskjell fra UTC"</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">"Bruker <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">"Bruker <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Ingen sommertid."</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">"Velg etter område"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Velg etter forskjell fra UTC"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Lås etter aktivering av skjermsparer"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> etter tidsavbrudd"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Rett etter tidsavbrudd, med mindre den holdes opplåst av <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> etter tidsavbrudd, med mindre den holdes opplåst av <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Legg til tekst på låseskjermen"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Ingen"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"F.eks. Petters Android."</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Posisjon"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Bruk posisjon"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Av"</string>
    <string name="location_settings_summary_location_on" msgid="7029728269719893381">"{count,plural, =1{På – # app har tilgang til posisjon}other{På – # apper har tilgang til posisjon}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Laster inn …"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Apper med tillatelsen for enheter i nærheten kan fastslå den relative posisjonen til tilkoblede enheter."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Posisjonstilgang er av for apper og tjenester. Enhetsposisjonen kan fremdeles sendes til utrykningspersonell når du ringer eller sender tekstmelding til et nødnummer."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="5329024810729665156">"Finn ut mer om posisjonsinnstillinger"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Kontoer"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Sikkerhet"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Kryptering og legitimasjon"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Låseskjerm"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Hva skal vises?"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Ikke tilgjengelig"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Sikkerhetsstatus"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Skjermlås, Finn enheten min, appsikkerhet"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Sikkerhet og personvern"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Appsikkerhet, enhetslås, tillatelser"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Ansiktet er lagt til"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Konfigurering kreves"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Ansiktslås"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Ansiktslås for jobb"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Slik konfigurerer du ansiktslås"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Konfigurer ansiktslås"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Bruk ansiktet ditt til å godkjenne"</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 ansiktslås med tilgjengelighet er slått av, fungerer muligens ikke enkelte konfigureringstrinn som de skal, med TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Gå tilbake"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Fortsett konfig."</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Bruk tilgjengelighetsoppsett"</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">"Avbryt"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Nei takk"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Godta"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Mer"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Lås opp med ansiktet ditt"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Tillat ansiktslås"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Bruk ansiktet ditt til å godkjenne"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Bruk ansiktet ditt til å låse opp telefonen eller godta kjøp.\n\nMerk: Du kan ikke bruke ansiktet til å låse opp denne enheten. Ta kontakt med administratoren for organisasjonen din for å få mer informasjon."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Bruk ansiktet til å låse opp telefonen, godkjenne kjøp eller logge på apper"</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">"Ha ansiktet ditt midt i sirkelen"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Hopp over"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Du har lagt til maksimalt antall ansikter"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Kan ikke legge til flere ansikter"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Registreringen er ikke fullført"</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">"Tidsgrensen for registrering av ansikt er nådd. Prøv på nytt."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Registreringen av ansiktet mislyktes."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Alt er klart. Det ser bra ut."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Ferdig"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Gjør ansiktslåsen bedre"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Konfigurer ansiktslåsen på nytt"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Konfigurer ansiktslåsen på nytt"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Få bedre sikkerhet og ytelse"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Konfigurer ansiktslås"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Slett den nåværende ansiktsmodellen din for å konfigurere ansiktslås igjen.\n\nAnsiktsmodellen blir slettet permanent og sikkert.\n\nEtter slettingen trenger du PIN-kode, mønster eller passord når du skal låse opp telefonen eller autentisere i apper."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Slett den nåværende ansiktsmodellen din for å konfigurere ansiktslås igjen.\n\nAnsiktsmodellen blir slettet permanent og sikkert.\n\nEtter slettingen trenger du fingeravtrykk, PIN-kode, mønster eller passord når du skal låse opp telefonen eller autentisere i apper."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Bruk ansiktslås til dette"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Når du bruker ansiktslås"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Øynene må være åpne"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Øynene dine må være åpne for å låse opp telefonen"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Krev alltid bekreftelse"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Krev alltid bekreftelsestrinnet når ansiktslås brukes i apper"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Slett ansiktsmodellen"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Konfigurer ansiktslås"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Vil du slette ansiktsmodellen?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Ansiktsmodellen din blir slettet permanent og sikkert.\n\nEtter slettingen trenger du PIN-kode, mønster eller passord når du skal låse opp telefonen eller autentisere i apper."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Ansiktsmodellen din blir slettet permanent og sikkert.\n\nEtter slettingen trenger du PIN-kode, mønster eller passord når du skal låse opp telefonen."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Ansiktsmodellen din blir slettet permanent og sikkert.\n\nEtter slettingen trenger du fingeravtrykk, PIN-kode, mønster eller passord når du skal låse opp telefonen eller autentisere i apper."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Ansiktsmodellen din blir slettet permanent og sikkert.\n\nEtter slettingen trenger du fingeravtrykk, PIN-kode, mønster eller passord når du skal låse opp telefonen."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Bruk ansiktslås til å låse opp telefonen"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Fingeravtrykk"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Fingeravtrykk"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Ved bruk av opplåsing med fingeravtrykk"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Fingeravtrykk for jobb"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Legg til fingeravtrykk"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{1 fingeravtrykk er lagt til}other{# fingeravtrykk er lagt til}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Konfigurering kreves"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Konfigurer fingeravtrykket"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Tillat bruk av fingeravtrykk"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Bruk fingeravtrykket ditt"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Finn ut mer om opplåsing med fingeravtrykk"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Du har kontrollen"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Du og barnet ditt har kontrollen"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Vær obs på dette"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Bruk fingeravtrykk til å låse opp telefonen eller godta kjøp.\n\nMerk: Du kan ikke bruke fingeravtrykk til å låse opp denne enheten. Ta kontakt med administratoren for organisasjonen din for mer informasjon."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Avbryt"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Nei takk"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Godta"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Hoppe over fingeravtrykk?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Det tar bare et minutt eller to å konfigurere fingeravtrykk. Hvis du hopper over dette, kan du legge til fingeravtrykket ditt senere i innstillingene."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Når du ser dette ikonet, kan du autentisere med fingeravtrykk, f.eks. når du logger på apper eller godkjenner kjøp"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Vær obs på dette"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Slik fungerer det"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Opplåsing med fingeravtrykk lager en unik modell av fingeravtrykket ditt for å bekrefte identiteten din. For å opprette denne fingeravtrykkmodellen under konfigureringen tar du bilder av fingeravtrykket ditt fra forskjellige posisjoner."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Opplåsing med fingeravtrykk lager en unik modell av fingeravtrykket til barnet ditt for å bekrefte barnets identitet. For å opprette denne fingeravtrykkmodellen under konfigureringen tar hen bilder av fingeravtrykket sitt fra forskjellige posisjoner."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Du får best resultater ved å bruke en skjermbeskytter som er Made For Google-sertifisert. Fingeravtrykket ditt fungerer muligens ikke med andre skjermbeskyttere."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Du får best resultater ved å bruke en skjermbeskytter som er Made For Google-sertifisert. Fingeravtrykket til barnet ditt fungerer muligens ikke med andre skjermbeskyttere."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Klokkelås"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="6583248094453119314">"Når du konfigurerer ansiktslås og opplåsing med fingeravtrykk, blir du bedt om å bruke fingeravtrykk når du har på deg munnbind eller er i områder med lite lys.\n\nDu kan låse opp enheten med klokken når ansiktet eller fingeravtrykket ditt ikke gjenkjennes."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="4312041617237493461">"Du kan låse opp enheten med klokken når fingeravtrykket ditt ikke gjenkjennes."</string>
    <string name="biometric_settings_intro_with_face" msgid="7658123658803417930">"Du kan låse opp enheten med klokken når ansiktet ditt ikke gjenkjennes."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Bruk fingeravtrykk eller klokke til å"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Bruk ansikt eller klokke til å"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Bruk ansikt, fingeravtrykk eller klokke til å"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Bruk klokke til å"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Bruk ansiktet eller klokken"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Bruk fingeravtrykket eller klokken"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Bruk ansiktet, fingeravtrykket eller klokken"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Bruk klokken"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Konfigurer ansiktslås eller opplåsing med fingeravtrykk"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Du kan låse opp enheten med klokken når ansiktet eller fingeravtrykket ditt ikke gjenkjennes."</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Konfigurer opplåsing med fingeravtrykk"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Du kan låse opp enheten med klokken når fingeravtrykket ditt ikke gjenkjennes"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Konfigurer ansiktslås"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Du kan låse opp enheten med klokken når ansiktet ditt ikke gjenkjennes"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Konfigurer"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Fingeravtrykket og <xliff:g id="WATCH">%s</xliff:g> er lagt til"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Fingeravtrykkene og <xliff:g id="WATCH">%s</xliff:g> er lagt til"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Ansiktet og <xliff:g id="WATCH">%s</xliff:g> er lagt til"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Ansiktet, fingeravtrykket og <xliff:g id="WATCH">%s</xliff:g> er lagt til"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Ansiktet, fingeravtrykkene og <xliff:g id="WATCH">%s</xliff:g> er lagt til"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Opplåsing med fingeravtrykk og ansiktslås"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Ansiktslås og opplåsing med fingeravtrykk for jobb"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Konfigurering kreves"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Ansikt og fingeravtrykk er lagt til"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Ansikt og fingeravtrykk er lagt til"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Når du konfigurerer ansiktslås og opplåsing med fingeravtrykk, blir du bedt om å bruke fingeravtrykk når du bruker munnbind eller er i et dårlig belyst område."</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Måter å låse opp på"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Bruk ansikt eller fingeravtrykk til dette"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Lås opp telefonen"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Bekreft i apper at du er deg"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Med ansiktet"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Bruk fingeravtrykket"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Bruk ansiktet eller fingeravtrykket"</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">"Kan ikke konfigurere Ansiktslås"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Avslutt delt skjerm for å konfigurere ansiktslås"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Kan ikke konfigurere fingeravtrykk"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Lukk delt skjerm og konfigurer fingeravtrykk"</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 hoppe over skjermlås?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Hopp over likevel"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Gå tilbake"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Hopp over"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Avbryt"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Berør sensoren"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Hold på av/på-knappen uten å trykke på den"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Slik konfigurerer du fingeravtrykket ditt"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Den er på baksiden av telefonen. Bruk pekefingeren."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Fingeravtrykkssensoren er på skjermen. Du registrerer fingeravtrykket på den neste skjermen."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Start"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Beveg fingeren over skjermen for å finne sensoren. Trykk og hold på fingeravtrykks-sensoren."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Illustrasjon med enheten og plasseringen av fingeravtrykksensoren"</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 igjen"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Slett"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Berør sensoren"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Legg fingeren på sensoren, og løft den når du kjenner en vibrasjon"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Hold fingeravtrykket flatt på sensoren til du føler en vibrering"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Uten å trykke på knappen holder du fingeravtrykket på sensoren til du føler en vibrasjon.\n\nFlytt fingeren litt hver gang. Dette bidrar til å registrere mer av fingeravtrykket."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Hold på sensoren"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Løft fingeren og berør igjen"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"En gang til"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Følg fingeravtrykkikonet"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Løft fingeren gjentatte ganger for å legge til de forskjellige delene av fingeravtrykket ditt"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Trykk og hold hver gang fingeravtrykkikonet beveger seg. Dette bidrar til å registrere mer av fingeravtrykket."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Plasser fingertuppen på sensoren"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Plasser venstre side av fingertuppen på sensoren"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Plasser høyre side av fingertuppen på sensoren"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Plasser midten av fingeren på sensoren"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Plasser fingertuppen på sensoren"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Plasser venstre side av fingeren på sensoren"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Plasser til slutt høyre side av fingeren på sensoren"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Plassér siden av fingeravtrykket på sensoren og hold. Bytt deretter til den andre siden"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Dette bidrar til å registrere mer av fingeravtrykket"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Registrerer fingeravtrykket: <xliff:g id="PERCENTAGE">%d</xliff:g> prosent"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Registrert <xliff:g id="PERCENTAGE">%d</xliff:g> prosent"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Registrerer fingeravtrykket: <xliff:g id="PERCENTAGE">%d</xliff:g> prosent"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Fingeravtrykket er lagt til"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Trykk for å låse opp når som helst"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Trykk på sensoren for å låse opp, selv om skjermen er av. Dette øker sannsynligheten for utilsiktede opplåsinger."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Skjerm, opplåsing"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Gjør det senere"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Løft fingeren og trykk igjen"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Plasser siden av fingeravtrykket på sensoren og hold. Bytt deretter til den andre siden."</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Vil du hoppe over fingeravtrykk-oppsett?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Du har valgt å bruke fingeravtrykket ditt som én måte å låse opp telefonen din på. Hvis du hopper over konfigureringen nå, må du fullføre den senere. Konfigureringen tar bare et par minutter."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Vil du hoppe over konfigureringen av <xliff:g id="OPTIONS">%s</xliff:g>?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Vil du hoppe over konfigurering av PIN-nummer?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Vil du hoppe over konfigurering av PIN-kode og ansikt?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Vil du hoppe over konfigurering av PIN-kode og fingeravtrykk?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Vil du hoppe over konfigurering av PIN-kode, ansikt og fingeravtrykk?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Vil du hoppe over konfigurering av passord?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Hopp over konfigurering av passord og ansikt?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Hopp over konfig. av passord og fingeravtrykk?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Avbryt konfig. passord, ansikt og fingeravtrykk?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Vil du hoppe over konfigurering av mønster?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Hopp over konfigurering av mønster og ansikt?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Hopp over konfig. av mønster og fingeravtrykk?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Avbryt konfig. mønster, ansikt og fingeravtrykk?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Konfigurer skjermlås"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Ferdig"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Ops, det er ikke sensoren"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Berør sensoren på baksiden av telefonen. Bruk pekefingeren."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Kan ikke fullføre fingeravtrykkonfigureringen"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Du kan prøve igjen nå eller konfigurere fingeravtrykket senere i Innstillinger."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Du kan prøve igjen nå eller konfigurere fingeravtrykket senere."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Konfigurering av fingeravtrykk er tidsavbrutt"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Du kan konfigurere fingeravtrykket senere i Innstillinger."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Noe gikk galt. Du kan konfigurere fingeravtrykket senere i Innstillinger."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Du kan konfigurere fingeravtrykket senere."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Noe gikk galt. Du kan konfigurere fingeravtrykket senere."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Legg til et til"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Neste"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Alternativet for skjermlås er slått av. For å finne ut mer, kontakt administratoren for organisasjonen din."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Du kan fortsatt bruke fingeravtrykket til å godkjenne kjøp og apptilgang."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Løft fingeren og legg den på sensoren igjen"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Kan ikke bruke fingeravtrykkssensoren"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Gå til en reparasjonsleverandør."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Flere sikkerhetsinnstillinger"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Lås for jobbprofil, kryptering med mer"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Kryptering, legitimasjon med mer"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"sikkerhet, flere sikkerhetsinnstillinger, flere innstillinger, avanserte sikkerhetsinnstillinger"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Flere personverninnstillinger"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Mer sikkerhet og personvern"</string>
    <string name="security_header" msgid="961514795852103424">"Sikkerhet"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Personvern"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Jobbprofil"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Du kan legge til opptil <xliff:g id="COUNT">%d</xliff:g> fingeravtrykk"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Du har lagt til maksimalt antall fingeravtrykk"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Kan ikke legge til flere fingeravtrykk"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Slett «<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>»"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Da kan du ikke bruke fingeravtrykket til å låse opp jobbprofilen din, autorisere kjøp eller logge på jobbapper."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Kryptering"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Kryptert"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Angi en skjermlås"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"For å øke sikkerheten, angi en PIN-kode, et mønster eller et passord for denne enheten."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Angi skjermlås"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Konfigurer en skjermlås"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"For å øke sikkerheten bør du angi en PIN-kode, et mønster eller et passord for denne enheten."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Sikre telefonen din"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Legg til fingeravtrykk for å låse opp"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Velg skjermlås"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Velg en skjermlås"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Velg en ny skjermlås"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Velg en lås for jobbapper"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Velg en ny jobblås"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Angi en skjermlås i reserve for bedre sikkerhet"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Velg hva slags reserveskjermlås du vil bruke"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Hvis du glemmer skjermlåsen din, kan ikke IT-administratoren tilbakestille den."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Angi en egen jobblås"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Hvis du glemmer denne låsen, kan du be IT-administratoren om å tilbakestille den"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Alternativer for skjermlås"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Alternativer for skjermlås"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Bekreft opplåsning automatisk"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Lås opp automatisk hvis du legger inn en riktig PIN-kode på minst 6 sifre. Dette er litt mindre sikkert enn å bekrefte med Enter."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Bekreft korrekt PIN-kode automatisk"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Det er sikrere å bekrefte PIN-koden med Enter enn å bruke automatisk bekreftelse"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Legg inn PIN-koden for enheten for å slå på automatisk bekreftelse"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Legg inn PIN-koden for enheten for å slå av automatisk bekreftelse"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Skjermlås"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Lås for jobbprofilen"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Ingen"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Sveip"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Mønster"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN-kode"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Passord"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Ikke nå"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Aktiv skjermlås"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Mønster • fingeravtrykk"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN-kode • fingeravtrykk"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Passord • fingeravtrykk"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Fortsett uten fingeravtrykk"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Mønster • ansikt"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN-kode • ansikt"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Passord • ansikt"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Fortsett uten ansiktslås"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Fortsett uten å registrere fingeravtrykket eller ansiktet"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Ingen"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Sveip"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Mønster"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN-kode"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Passord"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"Vil du slette skjermlå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 telefonen hvis den blir mistet eller stjålet"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Et mønster beskytter telefonen hvis den blir mistet eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette sletter også fingeravtrykkmodellen som er lagret på enheten. Da kan du ikke bruke fingeravtrykket til autentisering i apper."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Et mønster beskytter telefonen hvis den blir mistet eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Ansiktsmodellen blir også slettet permanent og sikkert. Du kan ikke bruke ansiktet til autentisering i apper."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Et mønster beskytter telefonen hvis den blir mistet eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette sletter fingeravtrykkmodellen som er lagret på enheten. Ansiktsmodellen blir også slettet permanent og sikkert. Da kan du ikke bruke ansiktet eller fingeravtrykket til autentisering i apper."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"En PIN-kode beskytter telefonen hvis den blir mistet eller stjålet"</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"En PIN-kode beskytter telefonen hvis den blir mistet eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette sletter også fingeravtrykkmodellen som er lagret på enheten. Da kan du ikke bruke fingeravtrykket til autentisering i apper."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"En PIN-kode beskytter telefonen hvis den blir mistet eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Ansiktsmodellen blir også slettet permanent og sikkert. Du kan ikke bruke ansiktet til autentisering i apper."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"En PIN-kode beskytter telefonen hvis den blir mistet eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette sletter fingeravtrykkmodellen som er lagret på enheten. Ansiktsmodellen blir også slettet permanent og sikkert. Da kan du ikke bruke ansiktet eller fingeravtrykket til autentisering i apper."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Et passord beskytter telefonen hvis den blir mistet eller stjålet"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Et passord beskytter telefonen hvis den blir mistet eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette sletter også fingeravtrykkmodellen som er lagret på enheten. Da kan du ikke bruke fingeravtrykket til autentisering i apper."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Et passord beskytter telefonen hvis den blir mistet eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Ansiktsmodellen blir også slettet permanent og sikkert. Du kan ikke bruke ansiktet til autentisering i apper."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Et passord beskytter telefonen hvis den blir mistet eller stjålet.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette sletter fingeravtrykkmodellen som er lagret på enheten. Ansiktsmodellen blir også slettet permanent og sikkert. Da kan du ikke bruke ansiktet eller fingeravtrykket til autentisering i apper."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Funksjoner for enhetsbeskyttelse kommer ikke til å fungere uten skjermlåsen din."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Funksjonene for enhetsbeskyttelse fungerer ikke uten skjermlåsen.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette sletter også fingeravtrykkmodellen som er lagret på enheten. Da kan du ikke bruke fingeravtrykket til autentisering i apper."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Funksjonene for enhetsbeskyttelse fungerer ikke uten skjermlåsen.<xliff:g id="EMPTY_LINE">

</xliff:g>Ansiktsmodellen blir også slettet permanent og sikkert. Du kan ikke bruke ansiktet til autentisering i apper."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Funksjonene for enhetsbeskyttelse fungerer ikke uten skjermlåsen.<xliff:g id="EMPTY_LINE">

</xliff:g>Dette sletter fingeravtrykkmodellen som er lagret på enheten. Ansiktsmodellen blir også slettet permanent og sikkert. Da kan du ikke bruke ansiktet eller fingeravtrykket til autentisering i apper."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Slett"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> anbefaler en sterk PIN-kode eller et sterkt passord og fungerer muligens ikke som den skal, hvis du ikke har det"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> anbefaler at du endrer PIN-kode eller passord og fungerer muligens ikke som den skal, hvis du ikke gjør det"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> anbefaler at du endrer mønster, PIN-kode eller passord og fungerer muligens ikke som den skal, hvis du ikke gjør det"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> anbefaler ny skjermlås"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Prøv på nytt. Forsøk <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> av <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Dataene dine blir slettet"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Hvis du oppgir feil mønster på neste forsøk, slettes dataene på denne enheten"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Hvis du skriver inn feil PIN-kode på neste forsøk, slettes dataene på denne enheten"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Hvis du skriver inn feil passord på neste forsøk, slettes dataene på denne enheten"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Hvis du oppgir feil mønster på neste forsøk, slettes denne brukeren"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Hvis du skriver inn feil PIN-kode på neste forsøk, slettes denne brukeren"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Hvis du skriver inn feil passord på neste forsøk, slettes denne brukeren"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Hvis du oppgir feil mønster på neste forsøk, slettes jobbprofilen din og tilknyttede data"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Hvis du skriver inn feil PIN-kode på neste forsøk, slettes jobbprofilen din og tilknyttede data"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Hvis du skriver inn feil passord på neste forsøk, slettes jobbprofilen din og tilknyttede data"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Må inneholde minst # tegn}other{Må inneholde minst # tegn}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Hvis du bare bruker tall, må passordet være minst 1 siffer}other{Hvis du bare bruker tall, må passordet være minst # sifre}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{PIN-koden må ha minst # siffer}other{PIN-koden må ha minst # sifre}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{PIN-koden må inneholde minst # siffer, men vi anbefaler {minAutoConfirmLen} sifre for bedre sikkerhet}other{PIN-koden må inneholde minst # sifre, men vi anbefaler {minAutoConfirmLen} sifre for bedre sikkerhet}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Må inneholde færre enn # tegn}other{Må inneholde færre enn # tegn}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Må inneholde færre enn # siffer}other{Må inneholde færre enn # sifre}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Enhetsadministratoren forbyr nylig brukt PIN-kode"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Dette kan ikke inkludere et ugyldig tegn"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Må inneholde minst 1 bokstav}other{Må inneholde minst # bokstaver}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Må inneholde minst 1 liten bokstav}other{Må inneholde minst # små bokstaver}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Må inneholde minst 1 stor bokstav}other{Må inneholde minst # store bokstaver}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Må inneholde minst 1 siffer}other{Må inneholde minst # sifre}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Må inneholde minst 1 spesialtegn}other{Må inneholde minst # spesialtegn}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Må inneholde minst 1 annet tegn enn bokstaver}other{Må inneholde minst # andre tegn enn bokstaver}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Må inneholde minst 1 tegn som ikke er et tall}other{Må inneholde minst # tegn som ikke er et tall}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Enhetsadministratoren forbyr nylig brukte passord"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"En sekvens av stigende, synkende eller like sifre er ikke tillatt"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Bekreft"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Fjern"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Skjermlåsen har allerede blitt endret. Prøv på nytt med den nye skjermlåsen."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Avbryt"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Neste"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Apper for enhetsadministrator"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Ingen aktive apper"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aktiv app}other{# aktive apper}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Pålitelige agenter"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Du må angi en skjermlås for å bruke denne funksjonen"</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 pålitelig agent}other{# aktive pålitelige agenter}}"</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 koble til <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="5310869364570266209">"Legg til et nytt medlem i det eksisterende koordinerte settet"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Bluetooth-sammenkoblingskode"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Skriv inn sammenkoblingskoden og trykk på Return eller Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"Personlig kode inneholder bokstaver eller symboler"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Vanligvis 0000 eller 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Må bestå av 16 siffer"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Det er mulig at du må skrive inn denne PIN-koden også på den andre enheten."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Det er mulig at du må oppgi dette passordet også på den andre enheten."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Bekreft for å koble til det koordinerte settet"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Gi tilgang til kontakter og anropslogg"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Kunne ikke koble til <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Tilgjengelige enheter"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Koble til"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Koble fra"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Koble sammen"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Når Bluetooth er slått på, kan enheten kommunisere med andre Bluetooth-enheter i nærheten."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Når Bluetooth er slått på, kan enheten kommunisere med Bluetooth-enheter i nærheten.\n\nFor å gi deg en bedre enhetsopplevelse kan apper og tjenester søke etter enheter i nærheten når som helst – selv når Bluetooth er slått av. Dette kan for eksempel brukes for å forbedre posisjonsbaserte funksjoner og tjenester. Du kan endre dette i innstillingene for Bluetooth-skanning."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Endre"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Enhetsdetaljer"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Tastaturinnstillinger"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Enhetens Bluetooth-adresse: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Enhetens Bluetooth-adresse:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Vil du glemme enheten?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Fjern tilknytning"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Vil du koble fra appen?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"<xliff:g id="APP_NAME">%1$s</xliff:g>-appen kobler ikke lenger til <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"På forsøksstadiet. Bedrer lydkvaliteten."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Glem enheten"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Koble fra appen"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maksimalt antall Bluetooth-lydenheter"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Velg maksimalt antall tilkoblede Bluetooth-lydenheter"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Feilsøkingslogg for NFC-stakk"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Øk loggføringsnivå for NFC-stakk"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Feilsøkingslogg med høyt detaljnivå for leverandører for NFC"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Inkluder flere enhetsspesifikke leverandørlogger i feilrapporter. Disse kan inneholde privat informasjon."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Ufiltrert NCI-logg for NFC"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Fang opp detaljerte NFC-pakker. Disse kan inneholde privat informasjon."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Vil du starte enheten på nytt?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Detaljert NFC-loggføring er bare beregnet på utviklingsformål. Det inkluderes ekstra NFC-data i feilrapporter. Dette kan omfatte privat informasjon. Hvis du vil endre denne innstillingen, må du starte enheten på nytt."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Start på nytt"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Cast"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"speil"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Slå på trådløs skjermdeling"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Finner ingen enheter i nærheten."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Kobler til"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Tilkoblet"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"I bruk"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Utilgjengelig"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Alternativer for trådløs skjerm"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Glem"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Ferdig"</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">"Logg på"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Åpne nettstedet"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"<xliff:g id="REMAINING_TIME">%1$s</xliff:g> gjenstår"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Utløper <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> Mbps"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> ønsker å slå på Wifi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> ønsker å slå av Wifi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Bekreft bytekode for feilsøkbare apper"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Tillat at ART bekrefter bytekode for feilsøkbare apper"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Vis oppdateringsfrekvens"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Vis skjermens nåværende oppdateringsfrekvens"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Krev opplåst enhet for NFC"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Klar til å overføre appinnhold via NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Av"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Utilgjengelig fordi NFC er slått av"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Når denne funksjonen er slått på, kan du beame appinnhold til en annen enhet som støtter nærfeltskommunikasjon (NFC). Du gjør dette ved å holde enhetene tett sammen. Du kan for eksempel beame nettsider, YouTube-videoer, kontakter med mer.\n\nDu holder bare enhetene mot hverandre (vanligvis rygg mot rygg) og trykker på skjermen. Appen avgjør hva som beames."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wifi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Bruk Wifi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Innstillinger for wifi"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Velg Wifi-nettverk"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Slår på Wifi …"</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Slår av Wifi …"</string>
    <string name="wifi_error" msgid="4903954145386086899">"Feil"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"5 GHz-bånd er ikke tilgjengelig i dette landet"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"I flymodus"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Varsle om offentlige nettverk"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Varsle når et offentlig nettverk av høy kvalitet er tilgjengelig"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Slå på wifi automatisk"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Wifi slås på igjen i nærheten av lagrede nettverk av høy kvalitet, for eksempel hjemmenettverket ditt"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Utilgjengelig fordi Posisjon er slått av. Slå på "<annotation id="link">"Posisjon"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Installer sertifikater"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"For å forbedre posisjonsnøyaktigheten kan apper og tjenester søke etter wifi-nettverk når som helst – også når Wifi er slått av. Dette kan for eksempel brukes til å forbedre posisjonsbaserte funksjoner og tjenester. Du kan endre dette i <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>innstillingene for wifi-skanning<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"For å forbedre posisjonsnøyaktigheten, slå på wifi-skanning i <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>innstillingene for wifi-skanning<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Bytt til mobildata automatisk"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Bruk mobildata når Wifi ikke har Internett-tilgang. Avgifter for databruk kan påløpe."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Legg til nettverk"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Wi‑Fi-innstillinger"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wifi slås på igjen automatisk"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wifi slås ikke på igjen automatisk"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi-Fi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Slå på wifi for å se tilgjengelige nettverk."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Søker etter nettverk …"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Du har ikke tillatelse til å endre Wifi-nettverk."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Vil du slå på wifi-skanning?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"For å slå på Wifi automatisk må du først slå på wifi-skanning."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Med wifi-skanning kan apper og tjenester søke etter enheter i nærheten når som helst, selv når Wifi er slått av. Dette kan for eksempel brukes til å forbedre posisjonsbaserte funksjoner og tjenester."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Slå på"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Wifi-skanning er slått på"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Avanserte alternativer"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Rullegardinliste med avanserte alternativer"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"vis"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Nettverksnavn"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Skriv inn SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Sikkerhet"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Skjult nettverk"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Hvis ruteren din ikke sender en nettverks-ID, men du vil koble til den i fremtiden, kan du angi at nettverket skal være skjult.\n\nDette kan utgjøre en sikkerhetsrisiko fordi telefonen sender signalet sitt regelmessig for å finne nettverket.\n\nRuterinnstillingene dine endres ikke hvis du setter nettverket til å være skjult."</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øringshastighet for sending"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Overføringshastighet for mottak"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Koblingshastighet"</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">"Lagret via"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"<xliff:g id="NAME">%1$s</xliff:g>-legitimasjon"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"EAP-metode"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Fase 2-autentisering"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"CA-sertifikat"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Laveste TLS-versjon"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Sertifikatstatus på nettet"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domene"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Brukersertifikat"</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">"Passord"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Vis passord"</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 foretrekkes"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"IP-innstillinger"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Personvern"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Abonnement"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Se eller endre abonnement"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Tilfeldig valgt MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Legg til en enhet"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Midtstill QR-koden nedenfor for å legge til enheten i «<xliff:g id="SSID">%1$s</xliff:g>»"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Skann QR-kode"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Midtstill QR-koden nedenfor for å koble til «<xliff:g id="SSID">%1$s</xliff:g>»"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Koble til wifi ved å skanne en QR-kode"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Del wifi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Skann denne QR-koden med en annen enhet for å koble til «<xliff:g id="SSID">%1$s</xliff:g>»"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Skann denne QR-koden for å koble til «<xliff:g id="SSID">%1$s</xliff:g>»"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Prøv på nytt. Hvis problemet vedvarer, kan du kontakte enhetsprodusenten."</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Noe gikk galt"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Sørg for at enheten er tilkoblet, ladet og slått på"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Sørg for at enheten er tilkoblet, ladet og slått på. Hvis problemet vedvarer, kan du kontakte enhetsprodusenten."</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Tilføying av «<xliff:g id="SSID">%1$s</xliff:g>» støttes ikke av denne enheten"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Prøv å plassere enheten nærmere Wifi-tilgangspunktet/-ruteren"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Sjekk passordet og prøv igjen"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Kontakt produsenten av enheten"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Sjekk tilkoblingen og prøv igjen"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Velg et nettverk"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Velg et nettverk for å koble til enheten din"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Vil du legge til denne enheten i «<xliff:g id="SSID">%1$s</xliff:g>»?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi deles med enheten"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Legg til en annen enhet"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Velg et annet nettverk"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Kunne ikke legge til enheten"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Fant en enhet"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Deler Wifi med denne enheten …"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Kobler til …"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Del wifi-sone"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="5246641326066972419">"Bekreft at det er deg"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Wifi-passord: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Passord for wifi-sone: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Automatisk tilkobling"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Tillat tilkobling til dette nettverket når det er innen rekkevidde"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Legg til en enhet"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Bruk en QR-kode for å legge til en enhet på dette nettverket"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR-kode er ikke et gyldig format"</string>
    <string name="retry" msgid="7542103800274026915">"Prøv på nytt"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Del med andre brukere av enheten"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(uendret)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Velg"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Flere sertifikater er lagt til)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Bruk systemsertifikat"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Ikke oppgi"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Trust on First Use"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Nettverksnavnet er for langt."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Du må angi et domene."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Sertifikat er påkrevd."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"<xliff:g id="APP_NAME">%1$s</xliff:g> ønsker å bruke nettverksskanning, også når Wifi er slått av, for bedre posisjonsnøyaktighet og andre formål. \n\nVil du tillate dette for alle apper som prøver å skanne?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"En ukjent app ønsker å bruke nettverksskanning, også når Wifi er slått av, for bedre posisjonsnøyaktighet og andre formål.\n\nVil du tillate dette for alle apper som prøver å skanne?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Tillat"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Avvis"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Dette nettverket har ikke internettilgang. Vil du fortsette å være koblet til nettverket?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Noen apper og tjenester fungerer muligens ikke på grunn av begrenset tilkobling. Bruke likevel?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Ikke spør igjen for dette nettverket"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Wi‑Fi er ikke koblet til Internett"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Du kan bytte til mobilnettverket når du har dårlig Wifi-tilkobling. Databrukkostnader kan påløpe."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Buytt til mobilnettverk"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Bli værende på Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Ikke vis igjen"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Koble til"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Wifi er slått på"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Koblet til <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Kobler til <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Kobler til …"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Kan ikke koble til nettverket"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Nettverket er ikke innen rekkevidde"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Glem"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Endre"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"Kunne ikke slette nettverket"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Lagre"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Kunne ikke lagre nettverket"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Avbryt"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Vil du glemme nettverket?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 nettverk}other{# nettverk}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 abonnement}other{# abonnementer}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 nettverk og abonnement}other{# nettverk og abonnementer}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Enhetens MAC-adresse"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Tilfeldig valgt MAC-adresse"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Tilfeldiggjort MAC-adresse (sist brukt)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Nettverksdetaljer"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Nettverksmaske"</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">"Informasjon om enheten for wifi-sonen"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Internettkilde"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"Wifi"</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">%s</xliff:g> – lader"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Tilkobling til wifi-sone"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Tilkoblingsstyrke"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Lagrede nettverk"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Abonnementer"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Andre nettverk"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Angi en gyldig IP-adresse."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Angi en gyldig gateway-adresse."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Angi en gyldig DNS-adresse."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Angi lengde for nettverksprefiks mellom 0 og 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (med mindre det overstyres av privat DNS)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (med mindre det overstyres av privat DNS)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Gateway"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Nettverksprefiks-lengde"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Søk etter enheter"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Søker …"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Gi enheten nytt navn"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Motpartsenheter"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Lagrede grupper"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Kunne ikke koble til."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Kunne ikke gi enheten nytt navn."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Vil du koble fra?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Hvis du kobler fra, avsluttes tilkoblingen med <xliff:g id="PEER_NAME">%1$s</xliff:g>."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Hvis du kobler fra, kommer tilkoblingen med <xliff:g id="PEER_NAME">%1$s</xliff:g> og <xliff:g id="PEER_COUNT">%2$s</xliff:g> andre enheter til å avsluttes."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Vil du avbryte invitasjonen?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Vil du avbryte invitasjonen til å koble til <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Vil du glemme denne gruppen?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Wifi-sone"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Deler ikke internett eller innhold med andre enheter"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Ingen passord er angitt"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Navn på wifi-sone"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Passord for wifi-sone"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"AP-bånd"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Slå av wifi-sone automatisk"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Når ingen enheter er tilkoblet"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Utvid kompatibilitet"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Dette hjelper andre enheter med å finne denne wifi-sonen. Dette reduserer tilkoblingshastigheten."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Dette hjelper andre enheter med å finne denne wifi-sonen. Øker batteribruken."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Hastighet og kompatibilitet"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2.4 GHz / kompatibel med de fleste enheter"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz / kompatibel med mange enheter"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz / kompatibel med få enheter"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2.4 og 5 GHz / kompatibel med de fleste enheter"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Velg en frekvens for wifi-sonen. Frekvensen påvirker tilkoblingshastigheten og hvilke typer enheter som kan finne wifi-sonen."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Foretrukket frekvens"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Lavere hastighet. Kompatibel med de fleste enheter."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Høy hastighet. Kompatibel med mange enheter."</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">"Høy hastighet. Denne wifi-sonen med to bånd er kompatibel med de fleste enheter."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Høyeste hastighet. Kompatibel med få enheter."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Ikke tilgjengelig i landet eller regionen du befinner deg i"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Hvis frekvensen du foretrekker, ikke er tilgjengelig, kan wifi-sonen bruke en annen. Sikkerhetsinnstillingene for wifi-sonen kan endres hvis du bytter frekvensen."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Ikke tilgjengelig med 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Sikkerhetsinnstillingene kan endres hvis du forandrer frekvensen for wifi-sonen"</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"Umiddelbar wifi-sone"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"På"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Av"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Slår på wifi-sone …"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Slår av trådløs sone …"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Internettdeling er utilgjengelig"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Kontakt operatøren din for å få mer informasjon"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> er aktiv"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Vil du lagre dette nettverket?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Lagrer …"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Lagret"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Kan ikke lagre. Prøv på nytt."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Vil du lagre nettverkene?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Lagrer <xliff:g id="NUMBER">%d</xliff:g> nettverk …"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Nettverkene er lagret"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Wifi-anrop"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Forleng anrop med Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Slå på Wi‑Fi-anrop for å forlenge dekningen"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Ringeinnstillinger"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Ringeinnstillinger"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Roaming-innstilling"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Roaming-innstilling"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wifi"</item>
    <item msgid="8622872038388687383">"Mobil"</item>
    <item msgid="3027927219952052398">"Bare wifi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wifi"</item>
    <item msgid="7566603075659706590">"Mobil"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Bruk mobilnettverk hvis Wifi er utilgjengelig"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Bruk Wifi hvis mobilnettverket er utilgjengelig"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Ring via Wi‑Fi. Samtalen avsluttes hvis du mister Wi‑Fi-tilkoblingen."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Når wifi-anrop er slått på, kan telefonen din dirigere telefonsamtaler via Wifi-nettverk eller operatørens nettverk, avhengig av hva du har angitt i innstillingene og hvilket signal som er sterkest. Før du slår på denne funksjonen, er det viktig å sjekke gebyrer og andre detaljer med operatøren din.<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 for nødssituasjoner"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Brukes som posisjonen din når du gjør et nødanrop over Wifi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Finn ut mer"</annotation>" om funksjoner for privat DNS"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"På"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktivér wifi-anrop"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Slå på wifi-anrop"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Koblet fra <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Lyd og vibrering"</string>
    <string name="account_settings" msgid="255404935489127404">"Kontoer"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Joobprofil-kontoer – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Personlig profil-kontoer"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Klon profilkontoene"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Jobbkonto – <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øk"</string>
    <string name="display_settings" msgid="7197750639709493852">"Skjerm"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Rotér skjermen automatisk"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Av"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"På"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"På – ansiktsbasert"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Ansiktsgjenkjenning"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Finn ut mer om automatisk rotasjon"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Skjermoppløsning"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Høy oppløsning"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Full oppløsning"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Full oppløsning bruker mer batteri. Hvis du endrer oppløsningen, kan det føre til at noen apper starter på nytt."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Valgt"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Farger"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Naturlig"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Forsterket"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Mettet"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Tilpasset"</string>
    <string name="brightness" msgid="6216871641021779698">"Lysstyrkenivå"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Tilpasset lysstyrke"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Lysstyrken på skjermen justeres automatisk etter omgivelser og aktiviteter. Du kan flytte glidebryteren manuelt for lære tilpasset lysstyrke om preferansene dine."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"På"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Av"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Vis hvitbalanse"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="fold_lock_behavior_title" msgid="786228803694268449">"Fortsett å bruke apper etter sammenlegging"</string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="3627278682437562787">"Øker oppdateringsfrekvensen automatisk fra 60 til <xliff:g id="ID_1">%1$s</xliff:g> Hz for noe innhold. Øker batteribruken."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Maks oppdateringsfrekvens"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Maksimal oppdateringsfrekvens for bedre trykkfølsomhet og animasjonskvalitet. Øker batteribruken."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Skjermoppmerksomhet"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Kameratilgang er nødvendig"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Kameratilgang kreves for skjermoppmerksomhet. Trykk for å administrere tillatelser for Personlig tilpasning på enheten"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Administrer tillatelser"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Forhindrer at skjermen slås av hvis du ser på den"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Skjermoppmerksomhet bruker frontkameraet til å se om noen ser på skjermen. Funksjonen utføres på enheten, og bilder blir aldri lagret eller sendt til Google."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Slå på skjermoppmerksomhet"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Hold skjermen på når du ser på den"</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Kamera er låst"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Kamera må låses opp for ansiktsgjenkjenning"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Kameraet må låses opp for skjermoppmerksomhet"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Kameratilgang kreves for ansiktsgjenkjenning. Trykk for å administrere tillatelser for Personlig tilpasning på enheten"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Administrer tillatelser"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Nattlys"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Nattlys gir skjermen en ravgul nyanse. Dette gjør det mer komfortabelt å se eller lese på skjermen i svakt lys, og det kan gjøre det enklere å sovne."</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">"Egendefinerte tidspunkt"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Fra solnedgang til soloppgang"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Starttid"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Sluttid"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensitet"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Blir aldri slått på automatisk"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Blir slått på automatisk klokken <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Blir slått på automatisk ved solnedgang"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Blir aldri slått av automatisk"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Blir slått av automatisk klokken <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Blir slått av automatisk ved soloppgang"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Nattlys er ikke på nå"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Enhetsposisjon kreves for å fastslå klokkeslett for soloppgang og solnedgang."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Posisjonsinnstillinger"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Slå på nå"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Slå av nå"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Slå på til soloppgang"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Slå av til solnedgang"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Mørk modus"</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">"Fra solnedgang til soloppgang"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Egendefinerte tidspunkt"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Slås på ved sengetid"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Status"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Blir aldri slått på automatisk"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Blir slått på automatisk ved solnedgang"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Blir slått på automatisk klokken <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Blir slått på automatisk ved sengetid"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Blir aldri slått av automatisk"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Blir slått av automatisk ved soloppgang"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Blir slått av automatisk klokken <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Slås av automatisk etter sengetid"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Mørkt tema bruker en svart bakgrunn for å få batteriet til å vare lenger på noen skjermer. Tidsplaner for mørkt tema blir ikke slått på før skjermen er slått av."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Mørkt tema følger tidsplanen din for sengetidsmodus"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Innstillinger for sengetidsmodus"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Skjermsparer"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Etter <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> med inaktivitet"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Ikke angitt"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Bakgrunnsbilde"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Bakgrunn og stil"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Startskjerm, låseskjerm"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Endre bakgrunn"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Gi skjermen et personlig preg"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Velg bakgrunnsbilde fra"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Tilpass telefonen"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Prøv forskjellige stiler, bakgrunner med mer"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Skjermsparer"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"skjermsparer"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Utilgjengelig fordi sengetidsmodus er på"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Bruk skjermsparer"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Når enheten lades / er i dokken"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Når enheten er dokket og lader"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Når enheten lader"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Når enheten er i dokken"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Aldri"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"På / <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Av"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Starttidspunkt"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Aktiver enheten med løftebevegelser"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Passiv skjerm"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Når skal det vises?"</string>
    <string name="doze_title" msgid="1523090408230862316">"Vekk skjermen ved varsler"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Når skjermen er mørk, slås den på for nye varsler"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Vis alltid klokke og info"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Økt batteribruk"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Fet tekst"</string>
    <string name="title_font_size" msgid="570613010306330622">"Skriftstørrelse"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Gjør tekst større eller mindre"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Innstillinger 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-kortet"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Endre SIM-PIN-kode"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"PIN-koden for SIM-kortet"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Lås SIM-kortet"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Lås opp SIM-kortet"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Gammel PIN-kode for SIM-kortet"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Ny PIN-kode for SIM-kort"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Skriv inn ny PIN-kode på nytt"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"SIM-kode for PIN-kort"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Skriv inn en PIN-kode på 4 til 8 sifre"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"PIN-kodene er ikke like"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"PIN-koden for SIM-kortet ble endret."</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Kan ikke slå av PIN-koden."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Kan ikke slå på PIN-koden."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"OK"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Avbryt"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Vil du bruke <xliff:g id="CARRIER">%1$s</xliff:g> for mobildata?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Du bruker <xliff:g id="CARRIER2_0">%2$s</xliff:g> for mobildata. Hvis du bytter til <xliff:g id="CARRIER1">%1$s</xliff:g>, brukes ikke <xliff:g id="CARRIER2_1">%2$s</xliff:g> for mobildata lenger."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Bruk <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Oppdater foretrukket SIM-kort?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> er det eneste SIM-kortet i enheten din. Vil du bruke dette SIM-kortet for mobildata, anrop og SMS-meldinger?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Vil du forbedre datadekningen?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"La enheten bytte til <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> for mobildata automatisk når det har bedre tilgjengelighet."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Anrop, meldinger og nettverkstrafikk er muligens synlige for organisasjonen din"</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Feil PIN-kode for SIM-kortet. Du må nå kontakte operatøren din for å låse opp enheten."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Feil PIN-kode for SIM-kortet. Du har # forsøk igjen før du må kontakte operatøren din for å låse opp enheten.}other{Feil PIN-kode for SIM-kortet. Du har # forsøk igjen.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Feil PIN-kode for SIM-kortet. Du har ett forsøk igjen før du må kontakte operatøren din for å låse opp enheten."</string>
    <string name="pin_failed" msgid="3726505565797352255">"PIN-koden for SIM-kortet ble avvist."</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Systemoppdateringer"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Android-versjon"</string>
    <string name="security_patch" msgid="4071756145347865382">"Sikkerhetsoppdatering for Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Modell"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Maskinvareversjon"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Produksjonsår"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"Utstyrs-ID"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Basisbåndversjon"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Kjerneversjon"</string>
    <string name="build_number" msgid="9009733242117579826">"Delversjonsnummer"</string>
    <string name="module_version" msgid="1787518340082046658">"Google Play-systemoppdatering"</string>
    <string name="battery_info" msgid="7873528123969546728">"Batteriinformasjon"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Ikke tilgjengelig"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Lagring"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Lagring og buffer"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Innstillinger for lagring"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (SIM-kortspor <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (SIM-kortspor <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (SIM-kortspor <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (primær)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"For å se, velg lagret nettverk"</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-versjon"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (SIM-kortspor <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (SIM-kortspor <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (primær)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"På"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Av"</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">"Nettverkstype for mobildata"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Nettverkstype for tale"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Operatørinformasjon"</string>
    <string name="status_data_state" msgid="525196229491743487">"Datatilgang"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Servicestatus"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Signalstyrke"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Nettverk"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"MAC-adresse for wifi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Enhetens MAC-adresse for wifi"</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">"Produksjonsdato"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Dato for første bruk"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Syklusantall"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Ikke tilgjengelig"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Beregner …"</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Gi nytt navn"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Montér"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Løs ut"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formater SD-kort som bærbar lagring"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formater kort"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formatér som bærbar"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formatér"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Overfør 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">"Frigjør lagringsplass"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Administrer lagring"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Frigjør plass"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Administrer og frigjør plass i Files-appen"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Andre brukere"</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> er montert"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Kunne ikke montere <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> ble løst ut på en trygg måte"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Kunne ikke løse ut <xliff:g id="NAME">%1$s</xliff:g> på en trygg måte"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Gi nytt navn til lagring"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"<xliff:g id="NAME_0">^1</xliff:g> er ødelagt. \n\n<xliff:g id="NAME_1">^1</xliff:g> må konfigureres før bruk."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Du kan formatere dette SD-kortet for å lagre bilder, videoer, musikk med mer og bruke dem på andre enheter. \n\n"<b>"Alle data på dette SD-kortet blir tømt."</b>" \n\n"<b>"Før formatering"</b>" \n\n"<b>"Sikkerhetskopier bilder og andre medier"</b>" \nFlytt mediefilene dine til alternativ lagring på denne enheten, eller overfør dem til en datamaskin via en USB-kabel. \n\n"<b>"Sikkerhetskopier apper"</b>" \nAlle apper som er lagret på <xliff:g id="NAME">^1</xliff:g>, blir avinstallert, og de tilhørende dataene blir tømt. For å beholde disse appene, flytt dem til alternativ lagring på denne enheten."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Når du løser ut <xliff:g id="NAME_0">^1</xliff:g>, slutter apper som er lagret på den å virke, og mediefiler som er lagret på den, blir ikke tilgjengelige før lagringsmediet settes inn igjen."</b>" \n\n<xliff:g id="NAME_1">^1</xliff:g> er formatert til å bare fungere med denne enheten. Lagringsmediet fungerer ikke på andre enheter."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"For å bruke appene, bildene eller dataene som <xliff:g id="NAME">^1</xliff:g> inneholder, sett den inn på nytt. \n\nAlternativt kan du velge å glemme denne lagringen hvis enheten ikke er tilgjengelig. \n\nHvis du velger å glemme, forsvinner alle dataene som enheten inneholder for alltid. \n\nDu kan installere appene på nytt senere, men dataene som er lagret på denne enheten, går tapt."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Vil du at enheten skal glemme <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Alle appene, bildene og dataene som er lagret på <xliff:g id="NAME">^1</xliff:g>, går tapt for alltid."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Systemet inkluderer filer som brukes for å kjøre Android versjon <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Brukere i gjestemodus 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">"Ikke fjern <xliff:g id="NAME">^1</xliff:g> mens det formateres."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"<xliff:g id="NAME">^1</xliff:g> er formatert"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Flytt <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Det tar bare et par øyeblikk å flytte <xliff:g id="APP">^1</xliff:g> og tilhørende data til <xliff:g id="NAME_0">^2</xliff:g>. Du kan ikke bruke appen før flyttingen er ferdig. \n\nIkke fjern <xliff:g id="NAME_1">^2</xliff:g> mens flyttingen pågår."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Du må låse opp brukeren <xliff:g id="APP">^1</xliff:g> for å 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">"Ikke fjern <xliff:g id="NAME">^1</xliff:g> under flyttingen. \n\n<xliff:g id="APP">^2</xliff:g>-appen på denne enheten blir ikke tilgjengelig før flyttingen er ferdig."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Hvordan skal du bruke <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">"Formater SD-kort som bærbar lagring"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Lagre blant annet bilder, videoer og musikk, og få tilgang til det fra andre enheter. &lt;a href=https://support.google.com/android/answer/12153449&gt;Finn ut mer om konfigurering av 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 <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"<xliff:g id="NAME_0">^1</xliff:g> må formateres for å lagre apper, filer og medier. \n\nFormatering tømmer eksisterende innhold på <xliff:g id="NAME_1">^2</xliff:g>. For å unngå å miste innhold, sikkerhetskopiér det til en annen <xliff:g id="NAME_2">^3</xliff:g> eller enhet."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Du må formatere <xliff:g id="NAME_0">^1</xliff:g> for å lagre bilder, videoer, musikk med mer. \n\nFormatering tømmer eksisterende innhold på <xliff:g id="NAME_1">^2</xliff:g>. For å unngå å miste innhold, sikkerhetskopier det til en annen enhet eller <xliff:g id="NAME_2">^3</xliff:g>."</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 innhold til <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"I løpet av flyttingen"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Ikke fjern <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"fungerer ikke enkelte apper"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Flytt innhold"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Flytt innhold senere"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Flytter innhold …"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Tregt <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Du kan fremdeles bruke <xliff:g id="NAME_0">^1</xliff:g>, men det kan være tregt. \n\nApper som er lagret på <xliff:g id="NAME_1">^2</xliff:g>, fungerer kanskje ikke som de skal, og overføring av innhold kan ta lang tid. \n\nPrøv å bruke et raskere <xliff:g id="NAME_2">^3</xliff:g>, eller bruk <xliff:g id="NAME_3">^4</xliff:g> som bærbar lagring i stedet."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Start på nytt"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Fortsett"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Du kan begynne å bruke <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Du kan begynne å bruke <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Du kan begynne å bruke <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Batteristatus"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Batterinivå"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Felles"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Fellesinnstillinger"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APN"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Rediger tilgangspunkt"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Ikke angitt"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Ikke angitt"</string>
    <string name="apn_name" msgid="6677695784108157953">"Navn"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN-navn"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proxy-tjener"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Port"</string>
    <string name="apn_user" msgid="5831763936428279228">"Brukernavn"</string>
    <string name="apn_password" msgid="7435086635953953029">"Passord"</string>
    <string name="apn_server" msgid="6997704279138388384">"Tjener"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"Proxy-tjener for MMS"</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">"Autentiseringstype"</string>
    <string name="apn_type" msgid="1835573305077788773">"APN-type"</string>
    <string name="apn_protocol" msgid="181529867160380010">"APN-protokoll"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Roamingprotokoll for APN"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Slå på/av APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN er på"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN er av"</string>
    <string name="bearer" msgid="3231443241639159358">"Bærer"</string>
    <string name="mvno_type" msgid="4734654257494971247">"MVNO-type"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"MVNO-verdi"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Slett APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"Nytt APN"</string>
    <string name="menu_save" msgid="6611465355127483100">"Lagre"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Avbryt"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"Navnefeltet kan ikke være tomt."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"APN kan ikke være tomt."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"MCC-feltet må bestå av tre siffer."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"MNC-feltet må bestå av to eller tre siffer."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Operatøren tillater ikke å legge til APN-er av typen %s."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Gjenoppretter standard APN-innstillinger."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Tilbakestill til standardvalg"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Tilbakestilling av standard APN-innstillinger er fullført."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Alternativer for tilbakestilling"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Tilbakestill innstillingene for mobilnettverk"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Dette tilbakestiller alle innstillinger for mobilnettverk"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Vil du tilbakestille innstillingene for mobilnettverk?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Tilbakestill Bluetooth og wifi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Dette tilbakestiller alle wifi- og Bluetooth-innstillinger. Denne handlingen kan ikke angres."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Tilbakestill"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth og wifi er tilbakestilt"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Slett eSIM-kort"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Dette fører ikke til at du sier opp noen mobilabonnementer. Kontakt operatøren din for å laste ned erstatnings-SIM-kort."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Tilbakestill innstillingene"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Vil du tilbakestille alle nettverksinnstillingene? Denne handlingen kan ikke angres."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Vil du tilbakestille alle nettverksinnstillinger og slette eSIM-kortene? Denne handlingen kan ikke angres."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Tilbakestill innstillingene"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Vil du tilbakestille?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Tilbakestilling av nettverket er ikke tilgjengelig for denne brukeren"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Nettverksinnstillingene er tilbakestilt"</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"Kan ikke slette SIM-kort"</string>
    <string name="reset_esim_error_msg" msgid="7279607120606365250">"eSIM-kort kan ikke slettes, på grunn av en feil.\n\nStart enheten på nytt og prøv igjen."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Slett alle data (tilbakestill til fabrikkstandard)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Slett alle data (tilbakestill)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"musikk"</li>\n<li>"bilder"</li>\n<li>"andre brukerdata"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIM-kort"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Dette sier ikke opp mobilabonnementet ditt."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Alle personopplysningene dine og appene du har lastet ned, blir slettet. Denne handlingen kan ikke angres."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Alle personopplysningene dine, inkludert nedlastede apper og SIM-kort, blir slettet. Denne handlingen kan ikke angres."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Vil du slette alle dataene?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Tilbakestilling til fabrikkstandard er ikke tilgjengelig for denne brukeren"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Tømmer"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Vent litt"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Samtaleinnstillinger"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Telefonsvarer, viderekobling, samtale venter, nummervisning"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"USB-internettdeling"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Flyttbar trådløs sone"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Bluetooth-internettdeling"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Internettdeling"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Wifi-sone og internettdeling"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Wifi-sone på, internettdeling"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Wifi-sone på"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Internettdeling"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Kan ikke bruke internettdeling eller flyttbare Wifi-soner mens Datasparing er på"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Bare wifi-sone"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Bare USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Bare Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Bare Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Wifi-sone, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Wifi-sone, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Wifi-sone, 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">"Wifi-sone, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Wifi-sone, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Wifi-sone, 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">"Wifi-sone, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Deler ikke internett med andre enheter"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Av"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Internettdeling"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"Ikke bruk wifi-sone"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Bare del internett via USB"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Bare del internett via Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Bare del internett via Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Bare del internett via USB og Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Bare del internett via USB og Ethernet"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Bare del internett via Bluetooth og Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Bare del internett via USB, Bluetooth og Ethernet"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"USB-internettdeling"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Bluetooth-internettdeling"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Ethernet-internettdeling"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Bruk wifi-sone og internettdeling for å gi andre enheter tilgang til internett via mobildataforbindelsen din. Apper kan også opprette en wifi-sone for å dele innhold med enheter i nærheten."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Bruk wifi-sone og internettdeling for å gi andre enheter tilgang til internett via mobildataforbindelsen din. Apper kan også opprette en wifi-sone for å dele innhold med enheter i nærheten."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Hjelp"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobilnettverk"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Mobilabonnement"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"SMS-app"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Vil du bytte SMS-app?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Vil du bruke <xliff:g id="NEW_APP">%1$s</xliff:g> i stedet for <xliff:g id="CURRENT_APP">%2$s</xliff:g> for SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Vil du bruke <xliff:g id="NEW_APP">%s</xliff:g> som SMS-app?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Vil du endre wifi-assistent?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Vil du bruke <xliff:g id="NEW_APP">%1$s</xliff:g> i stedet for <xliff:g id="CURRENT_APP">%2$s</xliff:g> til å administrere nettverkstilkoblingene?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Vil du bruke <xliff:g id="NEW_APP">%s</xliff:g> til å administrere nettverkstilkoblingene?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Ukjent SIM-operatør"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"<xliff:g id="OPERATOR">%1$s</xliff:g> mangler kjent nettsted for identitetshåndtering"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Sett inn SIM-kortet og start enheten på nytt"</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Koble deg til Internett"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Nylige posisjonsforespørsler"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Sted for jobbprofil"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Apper med posisjonstillatelse"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Posisjon er slått av"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# av {total} apper har tilgang til posisjon}other{# av {total} apper har tilgang til posisjon}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Nylig tilgang"</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 detaljer"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Ingen apper har bedt om posisjonen din i det siste"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Ingen apper har brukt posisjon nylig"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Høy batteribruk"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Lav batteribruk"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Wifi-skanning"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"La apper og tjenester søke etter wifi-nettverk når som helst, selv når wifi er slått av. Dette kan for eksempel brukes til å forbedre posisjonsbaserte funksjoner og tjenester."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Bluetooth-søking"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"La apper og tjenester søke etter enheter i nærheten når som helst, selv når Bluetooth er slått av. Dette kan for eksempel brukes til å forbedre posisjonsbaserte funksjoner og tjenester."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Posisjonstjenester"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Posisjonstjenester"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Bruk posisjon"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Kan ikke angi tidssonen 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">"Posisjon eller posisjonstjenester er av"</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">"Enhetsposisjonen er nødvendig"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"For å angi tidssonen med posisjonen din, slå på posisjon og oppdater innstillingene for tidssone"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Posisjonsinnstillinger"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Løs dette"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Avbryt"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Automatisk tidssone er av"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Gjenkjenning av tidssone basert på posisjon er slått av"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Gjenkjenning av tidssone basert på posisjon støttes ikke"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Du har ikke tillatelse til å endre gjenkjenning av tidssone"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Posisjonen kan brukes til å angi tidssonen"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Vis juridisk informasjon, status og programvareversjon"</string>
    <string name="legal_information" msgid="7509900979811934843">"Juridisk informasjon"</string>
    <string name="manual" msgid="3651593989906084868">"Brukerveiledning"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Forskriftsmessig merking"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Håndbok for sikkerhet og regelverk"</string>
    <string name="copyright_title" msgid="83245306827757857">"Opphavsrett"</string>
    <string name="license_title" msgid="8745742085916617540">"Lisens"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Google Play-system: oppdateringslisenser"</string>
    <string name="terms_title" msgid="2071742973672326073">"Betingelser"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"System WebView License"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Bakgrunner"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Leverandører av satellittbilder:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Brukerveiledning"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Det oppsto et problem ved innlasting av brukerveiledningen."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Tredjepartslisenser"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Kunne ikke hente lisensene."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"henter…"</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Laster inn …"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Angi et passord"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Angi et jobbpassord"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Angi en PIN-kode"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Angi en jobb-PIN-kode"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Angi et mønster"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"For å øke sikkerheten, angi et mønster for å låse opp enheten"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Angi et jobbmønster"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Angi passord for å bruke fingeravtrykk"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Angi mønster for å bruke fingeravtrykk"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Angi en PIN-kode for sikkerheten"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Angi PIN for å bruke fingeravtrykk"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Skriv inn passordet på nytt"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Skriv inn jobbpassordet på nytt"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Skriv inn jobbpassordet ditt"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Bekreft mønsteret"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Tegn jobbmønsteret"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Skriv inn PIN-koden på nytt"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Skriv inn jobb-PIN-koden på nytt"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Skriv inn jobb-PIN-koden din"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Passordene er ikke like"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"PIN-kodene er ikke like"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Tegn mønsteret ditt på nytt"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Valg for opplåsing"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Passordet er angitt"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"PIN-kode er angitt"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Mønster er angitt"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"For å bruke ansiktslås, angi et passord"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"For å bruke ansiktslås, angi et mønster"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"For å bruke ansiktslås, angi en PIN-kode"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Angi et passord for å bruke ansikt eller fingeravtrykk"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Angi et mønster for å bruke ansikt eller fingeravtrykk"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Angi en PIN-kode for å bruke ansikt eller fingeravtrykk"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Har du glemt passordet ditt?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Har du glemt mønsteret ditt?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Har du glemt PIN-koden din?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7401165571170203743">"Tegn mønsteret ditt for å fortsette"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Oppgi PIN-koden din for å fortsette"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Oppgi passordet ditt for å fortsette"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Tegn jobbmønsteret ditt for å fortsette"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Skriv inn jobb-PIN-koden din for å fortsette"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Skriv inn jobbpassordet ditt for å fortsette"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Bruk enhetsmønsteret ditt for bedre beskyttelse"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Skriv inn PIN-koden din for bedre beskyttelse"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Skriv inn enhetspassordet ditt for bedre beskyttelse"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Bruk jobbmønsteret ditt for bedre beskyttelse"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Skriv inn jobb-PIN-koden din for bedre beskyttelse"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Skriv inn jobbpassordet ditt for bedre beskyttelse"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Bekreft mønster"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Bekreft PIN-kode"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Bekreft passord"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Bekreft at det er deg"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"For å overføre Google-kontoer, innstillinger og andre ting, legg inn mønsteret for den andre enheten. Mønsteret krypteres."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"For å overføre Google-kontoer, innstillinger og andre ting, legg inn PIN-koden for den andre enheten. PIN-koden krypteres."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"For å overføre Google-kontoer, innstillinger og andre ting, legg inn passordet for den andre enheten. Passordet krypteres."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Bruk også mønster for å låse opp enheten"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Bruk også PIN-kode for å låse opp enheten"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Bruk også passord for å låse opp enheten"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Bekreft mønsteret"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"Bekreft PIN-koden"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Bekreft passordet"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Tegn mønsteret for å fortsette"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Skriv inn PIN-koden til enheten for å fortsette"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Skriv inn enhetspassordet for å fortsette"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Feil PIN-kode"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Feil passord"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Feil mønster"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Nødssituasjon"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Enhetssikkerhet"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Opplåsingsmønster"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Endre PIN-kode for opplåsning"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Tegn et opplåsingsmønster"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Trykk menyknappen for hjelp."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Løft fingeren når du er ferdig."</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Berør minst <xliff:g id="NUMBER">%d</xliff:g> punkter. Prøv på nytt."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Mønsteret er registrert"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Tegn mønsteret på nytt for å bekrefte"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Det nye opplåsingsmønsteret ditt"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Bekreft"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Tegn på nytt"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Slett"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Fortsett"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Opplåsingsmønster"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Krev mønster"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Krev mønster for å låse opp skjermen"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Gjør mønsteret synlig"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Bedre personvern knyttet til PIN-koder"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Slå av animasjoner mens du legger inn PIN-koden"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Gjør profilmønsteret synlig"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibrer ved trykk"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Av/på-knapp låser umiddelbart"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Med mindre den holdes opplåst av <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Opplåsingsmønster"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Opplåsingsmønster"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Hvordan tegne et opplåsingsmønster"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"For mange ugyldige forsøk. Prøv på nytt om <xliff:g id="NUMBER">%d</xliff:g> sekunder."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Appen er ikke installert på telefonen din."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Sikkerhet for jobbprofil"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Skjermlås for jobbprofilen"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Bruk samme lås"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Bruk samme lås for jobbprofilen og enhetsskjermen"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Vil du bruke én lås?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Enheten din bruker skjermlåsen for jobbprofilen. Jobbretningslinjene gjelder for begge låsene."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Låsen for jobbprofilen din oppfyller ikke sikkerhetskravene til organisasjonen din. Du kan bruke samme lås for enhetsskjermen og jobbprofilen, men alle retningslinjene for skjermlåser for jobbprofilen gjelder."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Bruk én lås"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Bruk én lås"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Den samme som enhetslåsen"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Administrer apper"</string>
    <string name="applications_settings" msgid="1941993743933425622">"App-info"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Innstillinger for app"</string>
    <string name="install_applications" msgid="3921609656584369901">"Ukjente kilder"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Tillat alle appkilder"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Nylig åpnede apper"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Se alle appene}other{Se alle de # appene}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Kontakt IT-administratoren din"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"De kan hjelpe deg med å tilbakestille PIN-koden, mønsteret eller passordet"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Avanserte innstillinger"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Aktiver flere innstillingsalternativer"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Info om appen"</string>
    <string name="storage_label" msgid="2522307545547515733">"Lagring"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Åpne som standard"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Standardinnstillinger"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Skjermkompatibilitet"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Tillatelser"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Buffer"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Tøm bufferen"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Buffer"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 element}other{# elementer}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Fjern tilgang"</string>
    <string name="controls_label" msgid="8671492254263626383">"Kontroller"</string>
    <string name="force_stop" msgid="2681771622136916280">"Tving avslutning"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Totalt"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Appstørrelse"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"USB-lagring for app"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Brukerdata"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Avinstaller"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Avinstaller for alle brukere"</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">"Tøm lagring"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Avinstaller oppdateringer"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Tillat begrensede innstillinger"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Noen aktiviteter du har valgt, åpnes som standard i denne appen."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Du har valgt å tillate at denne appen oppretter moduler og leser moduldataene."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Ingen standardvalg er angitt."</string>
    <string name="clear_activities" msgid="488089228657585700">"Fjern standardinnstillingene"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Denne appen er kanskje ikke utformet for skjermen din. Du kan kontrollere hvordan den justerer seg til skjermen her."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Spør ved oppstart"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Skalér app"</string>
    <string name="unknown" msgid="8192160131923461175">"Ukjent"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Sorter etter navn"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Sorter etter størrelse"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Siste varsler"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Oftest"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Vis aktive tjenester"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Vis bufrede prosesser"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Nødapp"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Tilbakestill app-innstillingene"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Vil du tilbakestille app-innstillingene?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Dette tilbakestiller alle innstillinger for\n\n"<li>"deaktiverte apper"</li>\n<li>"deaktiverte appvarsler"</li>\n<li>"standardapper for handlinger"</li>\n<li>"begrensninger for bakgrunnsdata for apper"</li>\n<li>"eventuelle tillatelsesbegrensninger"</li>\n<li>"innstillinger for batteribruk"</li>\n\n"Du mister ingen appdata."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Tilbakestill apper"</string>
    <string name="filter" msgid="9039576690686251462">"Filter"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Velg filteralternativer"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Alle apper"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Deaktiverte apper"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Tredjeparts"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Kjører"</string>
    <string name="not_installed" msgid="5074606858798519449">"Ikke installert for brukeren"</string>
    <string name="installed" msgid="2837449358488825884">"Installert"</string>
    <string name="no_applications" msgid="985069304755391640">"Ingen apper."</string>
    <string name="internal_storage" msgid="999496851424448809">"Intern lagring"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Beregner størrelse på nytt…"</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Vil du slette appdataene?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Dataene i denne appen, inkludert filer og innstillinger, slettes permanent fra denne enheten"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"OK"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Avbryt"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Slett"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Finner ikke appen i listen over installerte apper."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Kunne ikke frigi lagringsplass for appen."</string>
    <string name="computing_size" msgid="4915310659841174866">"Beregner fortsatt…"</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Kunne ikke beregne pakkestørrelsen."</string>
    <string name="version_text" msgid="7628938665256107608">"versjon <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Flytt"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"En annen overføring pågår allerede."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Ikke nok lagringsplass."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Appen eksisterer ikke."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Det installerte stedet er ikke gyldig."</string>
    <string name="system_package" msgid="7559476279008519360">"Systemoppdateringer kan ikke installeres på eksterne medier."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Administratorappen på enheten kan ikke installeres på eksterne medier"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Vil du tvinge avslutning?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Hvis du tvinger avslutning av en app, kan det oppstå problemer."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Deaktiver appen"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Hvis du slår av denne appen, slutter muligens Android og andre apper å fungere som de skal. Husk at du ikke kan slette denne appen fordi den var forhåndsinstallert på enheten din. Ved å slå av, slår du av denne appen og skjuler den på enheten din."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Butikk"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Informasjon om appen"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Appen er installert fra <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Mer informasjon på <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Kjøres"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(aldri brukt)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Bruk av lagringsplass"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Starter på nytt"</string>
    <string name="cached" msgid="5379485147573438201">"Bufret bakgrunnsprosess"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Ingenting kjører."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Startet av 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> brukt"</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">"Bruker:<xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Brukeren ble fjernet"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> prosess 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> prosess 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> prosesser 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> prosesser og <xliff:g id="NUMSERVICES">%2$d</xliff:g> tjenester"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Enhetsminne"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Appenes RAM-bruk"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"System"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Apper"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Ledig"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Brukt"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Bufret"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Kjørende apper"</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">"Prosesser"</string>
    <string name="service_stop" msgid="5712522600201308795">"Stopp"</string>
    <string name="service_manage" msgid="3896322986828332075">"Innstillinger"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Denne tjenesten ble startet av appen den tilhører. Hvis du stopper tjenesten, kan det føre til at appen ikke fungerer slik den skal."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Denne appen kan ikke stoppes på en trygg måte. Hvis du stopper den, kan du miste noe av arbeidet du holder på med."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Dette er en gammel app-prosess som fortsatt kjører i tilfelle den trengs igjen. Det er vanligvis ingen grunn til å stoppe den."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: er i bruk for øyeblikket. Trykk på Innstillinger for å gjøre endringer."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Viktigste prosessen i bruk."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Tjenesten <xliff:g id="COMP_NAME">%1$s</xliff:g> er i bruk."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Leverandøren <xliff:g id="COMP_NAME">%1$s</xliff:g> er i bruk."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Vil du stoppe systemtjenesten?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Språk, inndata og bevegelser"</string>
    <string name="language_settings" msgid="8700174277543875046">"Språk og inndata"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Språk"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Tastatur"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Du har ikke tillatelse til å endre språket på enheten."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Språk og inndata"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Verktøy"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Tastatur og inndatametoder"</string>
    <string name="system_language" msgid="1146762166579643257">"Systemspråk"</string>
    <string name="phone_language" msgid="5986939176239963826">"Språk"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Automatisk erstatting"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Rett opp stavefeil"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Automatisk stor forbokstav"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Start setninger automatisk  med stor bokstav"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Autopunktum"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Innstillinger for fysisk tastatur"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Trykk mellomromstasten to ganger for å skrive punktum"</string>
    <string name="show_password" msgid="7101900779571040117">"Vis passord"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Vis tegnene et øyeblikk mens du skriver"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Denne stavekontrollen kan være i stand til å samle all tekst du skriver, herunder personlige opplysninger som passord og kredittkortnumre. Den kommer fra appen <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Vil du bruke denne stavekontrollen?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Innstillinger"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Språk"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Tastaturer"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Skjermtastatur"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Tilgjengelig skjermtastatur"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Administrer skjermtastaturer"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Alternativer"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fysisk tastatur"</string>
    <string name="show_ime" msgid="4334255501724746849">"Bruk skjermtastaturet"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Ha det på skjermen når det fysiske tastaturet er aktivt"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Hurtigtaster"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Vis listen over hurtigtaster"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Tastatur og verktøy i jobbprofilen"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Skjermtastatur for jobb"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Standard"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Styreflate"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Styreflate og mus"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Pekerhastighet, bevegelser"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Trykk for å klikke"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Styreflatebevegelser"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Tilpass enkeltbevegelser for styreflatenavigasjon"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Omvendt rulling"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Innholdet flyttes opp når du ruller ned"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Trykk nederst til høyre"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Trykk nederst til høyre på styreflaten for alternativer"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Pekerhastighet"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Lær styreflatebevegelser"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Gå til startsiden"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Sveip opp med tre fingre hvor som helst på styreflaten"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Gå tilbake"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Sveip med tre fingre fra venstre eller høyre"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Se nylige apper"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Sveip opp med tre fingre, hold, og slipp opp"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Se varsler og hurtiginnstillinger"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Sveip ned med tre fingre på startskjermen"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Bytt app"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Sveip mot venstre eller høyre med fire fingre"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Hopp over"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Neste"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Start på nytt"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Ferdig"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Gå tilbake"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Sveip til venstre eller høyre med tre fingre"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Gå til startsiden"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Sveip opp med tre fingre"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Nylige apper"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Sveip opp med tre fingre og hold"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Varsler"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Sveip ned med tre fingre"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Bytt app"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Sveip til venstre eller høyre med fire fingre"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Modifikatortaster"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Endre atferden til nøkler"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Tilbakestill 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 tilbakestille alle modifikatortastene til standard?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Ferdig"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Avbryt"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Tilbakestill"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Velg modifikatortast"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Velg en ny tast for <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">"Pekerhastighet"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Spillkontroller"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Viderekoble vibrering"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Send vibrering til spillkontrolleren hvis den er koblet til"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Velg et tastaturoppsett"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Konfigurer tastaturoppsett"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Bytt ved å trykke på Ctrl+Mellomromstasten"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Standard"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Tastaturoppsett"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Oppsett for fysiske tastaturer"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Personlig ordliste"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Personlig ordbok for jobb"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Legg til ord som skal brukes i apper som stavekontroll"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Legg til"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Legg til ordliste"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Uttrykk"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Flere alt."</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Færre alt."</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">"Snarvei:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Språk:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Skriv inn et ord"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Valgfri snarvei"</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">"Slett"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Du har ingen ord i brukerordlisten. For å legge til ord, trykk på Legg til-knappen (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"For alle språk"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Flere språk"</string>
    <string name="testing" msgid="6294172343766732037">"Testing"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Skjermtastatur, verktøy"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Skjermtastatur, fysisk tastatur, verktøy"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fysisk tastatur"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Oppsett"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Velg gadget"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Velg skrivebordselement"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Vil du opprette modulen og gi tilgang?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Når du har opprettet modulen, får appen tilgang til alt som vises.\n\nApp: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nModul: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Gi alltid <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> tillatelse til å opprette moduler og lese moduldata"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Bruksstatistikk"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Sorter etter brukstid"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Sorter etter sist brukt"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Sorter etter appnavn"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Sist brukt"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Brukstid"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Tilgjengelighet"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Tilgjengelighetsinnstillinger"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Skjerm, interaksjon, lyd"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Synsinnstillinger"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Du kan tilpasse denne enheten etter egne behov. Tilgjengelighetsfunksjonene kan du endre senere i Innstillinger."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Endre skrift­­størrelse"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Skjermleser"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Teksting"</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">"Skjerm"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Farge og bevegelse"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Gjør skjermen mørkere"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaksjonskontroller"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Tidskontroller"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Systemkontroller"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Nedlastede apper"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"På forsøksstadiet"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Funksjonsflagg"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filtrering av Bluetooth HCI snoop-loggen"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Angi filtre"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Du må slå Bluetooth av og på for at endringene skal tre i kraft"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"PBAP for filtrering av Bluetooth HCI snoop-logg"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"MAP for filtrering av Bluetooth HCI snoop-logg"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Angi filtreringsmodus. (Du må slå Bluetooth av og på for at endringene skal tre i kraft)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Still modusen for Bluetooth HCI snoop-loggen til «Filtrering er slått på» for å endre dette"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Skjermleseren er hovedsakelig for blinde og svaksynte"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Trykk på elementer på skjermen for å få dem opplest"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Valg for teksting"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Om innstillinger for teksting"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Finn ut mer om innstillinger for teksting"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Forstørring"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Forstørring-snarvei"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Forstørr skriving"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Forstørrelsesglasset følger teksten når du skriver"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"La være på ved appbytte"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Forstørrelsesglasset blir værende på og zoomer ut når du bytter app"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Joystick"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Aktiver og flytt forstørringen med joysticken på skjermen. Trykk og hold og dra joysticken for å kontrollere forstørringen. Trykk og dra for å flytte selve joysticken."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Om forstørring"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Finn ut mer om forstørring"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Forstørringstype"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Forstørr hele skjermen eller et bestemt område, eller bytt mellom de to alternativene."</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Fullskjerm"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"En del av skjermen"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Bytt mellom hele og en del av skjermen"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Velg hvordan du vil forstørre"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Forstørr hele skjermen"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Forstørr en del av skjermen"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Bytt mellom hele og en del av skjermen"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Trykk på Bytt-knappen for å bytte mellom alternativene"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Vil du bytte til en Tilgjengelighet-knapp?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Hvis du bruker trippeltrykk for å forstørre en del av skjermen, blir skriving og andre handlinger forsinket.\n\nTilgjengelighet-knappen flyter over andre apper på skjermen. Trykk på den for å forstørre."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Bytt til en Tilgjengelighet-knapp"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Bruk trippeltrykk"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Dette kan gjøre tastaturet tregere"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Når du trippeltrykker for å forstørre en del av skjermen, kan du merke problemer over tastaturet.\n\nFor å unngå dette kan du endre forstørringssnarveien fra trippeltrykk til et annet alternativ.\n"<annotation id="link">"Endre innstillingen"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Fortsett likevel"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Avbryt"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Innstillinger for forstørring"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Forstørr med trippeltrykk"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Forstørr med snarvei"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Forstørr med snarvei og trippeltrykk"</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">"Visningsstørrelse og tekst"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Endre hvordan tekst vises"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Emne: design for varmluftsballonger"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Fra: Bjarne"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"God morgen!\n\nJeg vil bare sjekke hvordan utviklingen av designene går. Blir de klare før vi begynner å lage de nye ballongene?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Tilbakestill valgene"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Skjermstørrelsen og tekstinnstillingene er tilbakestilt"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Vil du tilbakestille visningsstørrelse og tekst?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Tilbakestill"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Har du planer for helgen?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Jeg skal til stranden. Vil du være med?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Alternativer"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Zoom inn på skjermen"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Trykk tre ganger for å zoome"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Trykk på en knapp for å zoome"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Zoom raskt inn på skjermen for å gjøre innhold større"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Slik zoomer du inn:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Bruk snarveien for å starte forstørring.&lt;br/&gt; {1,number,integer}. Trykk på skjermen.&lt;br/&gt; {2,number,integer}. Dra to fingre for å bevege deg rundt på skjermen.&lt;br/&gt; {3,number,integer}. Klyp med to fingre for å justere zoomen.&lt;br/&gt; {4,number,integer}. Bruk snarveien for å stoppe forstørring.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Slik zoomer du inn midlertidig:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Sørg for at forstørringstype er satt til fullskjerm.&lt;br/&gt; {1,number,integer}. Bruk snarveien for å starte forstørring.&lt;br/&gt; {2,number,integer}. Trykk og hold hvor som helst på skjermen.&lt;br/&gt; {3,number,integer}. Dra en finger for å bevege deg rundt på skjermen.&lt;br/&gt; {4,number,integer}. Løft fingeren for å stoppe forstørring."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Når forstørrelse er slått på, kan du zoome inn på skjermen.\n\n"<b>"For å zoome"</b>", start forstørring og trykk hvor som helst på skjermen.\n"<ul><li>"Dra to eller flere fingre for å rulle"</li>\n<li>"Knip to eller flere fingre for å justere zoomen"</li></ul>\n\n<b>"For å zoome midlertidig"</b>", start forstørring og trykk og hold hvor som helst på skjermen.\n"<ul><li>"Dra for å bevege deg rundt på skjermen"</li>\n<li>"Løft fingeren for å zoome ut"</li></ul>\n\n"Du kan ikke zoome inn på tastaturet eller navigasjonsraden."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Side <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> av <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Bruk Tilgjengelighet-knappen for å åpne"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Hold volumtastene for å åpne"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Trippeltrykk på skjermen for å åpne"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Bruk bevegelse for å åpne"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Bruk tilgjengelighetsbevegelse"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"For å bruke denne funksjonen må du trykke på Tilgjengelighet-knappen <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> nederst på skjermen.\n\nFor å bytte mellom funksjoner, trykk og hold på Tilgjengelighet-knappen."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"For å bruke denne funksjonen, trykk på Tilgjengelighet-knappen på skjermen."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"For å bruke denne funksjonen, trykk og hold inne begge volumtastene."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"For å starte og stoppe forstørrelse, trippeltrykk hvor som helst på skjermen."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"For å bruke denne funksjonen, sveip opp fra bunnen av skjermen med to fingre.\n\nFor å bytte mellom funksjoner, sveip opp med to fingre og hold."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"For å bruke denne funksjonen, sveip opp fra bunnen av skjermen med tre fingre.\n\nFor å bytte mellom funksjoner, sveip opp med tre fingre og hold."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"For å bruke en tilgjengelighetsfunksjon, sveip opp fra bunnen av skjermen med to fingre.\n\nFor å bytte mellom funksjoner, sveip opp med to fingre og hold."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"For å bruke en tilgjengelighetsfunksjon, sveip opp fra bunnen av skjermen med tre fingre.\n\nFor å bytte mellom funksjoner, sveip opp med tre fingre og hold."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Greit"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="1624189347106713695">"Innstillinger for knappen"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"<xliff:g id="SERVICE">%1$s</xliff:g>-snarvei"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Tilgjengelighet-knapp"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Tilgjengelighetsbevegelse"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Sveip opp med to fingre"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Sveip opp med tre fingre"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Trykk på Tilgjengelighet-knappen"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Bruk tilgjengelighetsbevegelse"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Trykk på Tilgjengelighet-knappen <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> nederst på skjermen.\n\nFor å bytte mellom funksjoner, trykk og hold inne Tilgjengelighet-knappen."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Sveip opp fra bunnen av skjermen med to fingre.\n\nFor å bytte mellom funksjoner, sveip opp med to fingre og hold."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Sveip opp fra bunnen av skjermen med tre fingre.\n\nFor å bytte mellom funksjoner, sveip opp med tre fingre og hold."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Flere alternativer"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Finn ut mer om <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Hold inne volumtastene"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"hold inne volumtastene"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Trykk og hold inne begge volumtastene"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Trippeltrykk på skjermen"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"trippeltrykk på skjermen"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Trykk raskt på skjermen {0,number,integer} ganger. Denne snarveien kan gjøre enheten tregere"</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Avansert"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Tilgjengelighet-knappen er satt til <xliff:g id="SERVICE">%1$s</xliff:g>. For å bruke forstørrelse, trykk på og hold inne Tilgjengelighet-knappen, og velg deretter forstørrelse."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Tilgjengelighetsbevegelsen er satt til <xliff:g id="SERVICE">%1$s</xliff:g>. For å bruke forstørring, sveip opp med to fingre fra bunnen av skjermen og hold. Deretter velger du forstørring."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Snarvei til volumtast"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Snarvei-innstillinger"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Snarvei fra låseskjermen"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Tillater at funksjonssnarveien slås på fra låseskjermen. Hold inne begge volumtastene i noen sekunder."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Tilgjengelighet-knapp"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Tilgjengelighet-knapp og bevegelse"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Få rask tilgang til tilgjengelighetsfunksjoner fra hvilken som helst skjerm"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Om Tilgjengelighet-knappen"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Om Tilgjengelighet-knappen og -bevegelsen"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Finn ut mer om Tilgjengelighet-knappen og -bevegelsen"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Bruk av Tilgjengelighet-knappen. Bevegelsen er ikke tilgjengelig med navigasjon med tre knapper."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Rask tilgang til tilgjengelighetsfunksjoner"</string>
    <string name="accessibility_button_gesture_description" msgid="7507097717493960397"><b>"Slik kommer du i gang"</b>\n"1. Gå til tilgjengelighetsinnstillingene.\n2. Velg en funksjon og trykk på snarveien.\n3. Velg om du vil bruke en knapp eller bevegelse for å åpne funksjonen."</string>
    <string name="accessibility_button_description" msgid="1261273371298608222"><b>"Slik kommer du i gang"</b>\n"1. Gå til tilgjengelighetsinnstillingene.\n2. Velg en funksjon og trykk på snarveien.\n3. Velg knappen du vil bruke for å åpne funksjonen."</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Bruk knapp eller bevegelse"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Posisjon"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Størrelse"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Tones ut når den ikke er i bruk"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Tones ut etter noen sekunder, slik at det er enklere å se skjermen."</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Gjennomsiktighet når den ikke er i bruk"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Gjennomsiktig"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Ikke-gjennomsiktig"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Tekst med høy kontrast"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Endre tekstfarge til svart eller hvit. Dette maksimerer kontrasten mot bakgrunnen."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Automatisk oppdatering av skjermforstørrelsen"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Oppdater skjermforstørrelsen ved appbytter"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Legg på med av/på-knappen"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Stor musepeker"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Gjør musepekeren mer synlig"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Fjern animasjoner"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Reduser bevegelse på skjermen"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Monolyd"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Kombiner kanaler når du spiller av lyd"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Lydbalanse"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Venstre"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Høyre"</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 minutt"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minutter"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Tidsperiode for handling (ventetid)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Om tidsperiode for handling (ventetid)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Finn ut mer om tidsperiode for handling (ventetid)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Tidsperiode for handling"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Denne tidsinnstillingen støttes ikke av alle apper"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Velg hvor lenge du vil se midlertidige meldinger som ber deg gjøre noe"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Forsinkelse for trykk-og-hold"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Fargeinvertering"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Bruk fargeinvertering"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Snarvei til fargeinvertering"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Med fargeinvertering blir lyse skjermer mørke. I tillegg blir mørke skjermer lyse."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Husk&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt;&amp;nbsp;Farger endres i medier og bilder.&lt;/li&gt; &lt;li&gt;&amp;nbsp;Fargeinvertering fungerer i alle apper.&lt;/li&gt; &lt;li&gt;&amp;nbsp;For å vise mørke bakgrunner kan mørkt tema brukes i stedet.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_action_label_panel_slice" msgid="1313725957071602932">"åpne innstillingene"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Autoklikk (holdetid)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Om autoklikk (holdetid)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Finn ut mer om autoklikk (holdetid)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Du kan angi at en tilkoblet mus skal klikke automatisk når markøren slutter å bevege seg i en viss tid."</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Autoklikk kan være nyttig når det er vanskelig å klikke med musen"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Autoklikk er av"</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">"Middels"</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">"Lengre"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Tid for autoklikk"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibrering og fysisk tilbakemelding"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Kontroller vibrasjonsstyrken for forskjellig bruk"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"På"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Av"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Innstillingen er slått av fordi enheten er satt til lydløs"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Anrop"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Varsler og alarmer"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Interaktiv fysisk tilbakemelding"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Bruk vibrering og fysisk tilbakemelding"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Alarmvibrering"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Medievibrering"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Ringevibrering"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Varselvibrering"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Tilbakemelding ved berøring"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Bruk <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Åpne <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 lagt til i hurtiginnstillingene. Sveip ned for å slå det av eller på når som helst."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Du kan også legge til <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> i hurtiginnstillingene fra toppen av skjermen"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Fargekorrigering er lagt til i hurtiginnstillingene. Sveip ned for å slå det av eller på når som helst."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Du kan også legge til fargekorrigering i hurtiginnstillingene fra toppen av skjermen"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Fargeinvertering er lagt til i hurtiginnstillingene. Sveip ned for å slå det av eller på når som helst."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Du kan også legge til fargeinvertering i hurtiginnstillingene fra toppen av skjermen"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Ekstra dimmet er lagt til i hurtiginnstillingene. Sveip ned for å slå det av eller på når som helst."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Du kan også legge til ekstra dimmet i hurtiginnstillingene fra toppen av skjermen"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Enhåndsmodus er lagt til i hurtiginnstillingene. Sveip ned for å slå den av eller på når som helst."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Du kan også legge til enhåndsmodus i hurtiginnstillingene fra toppen av skjermen"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Skriftstørrelse er lagt til i hurtiginnstillingene. Sveip ned når som helst for å endre skriftstørrelsen."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Lukk"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Bruk fargekorrigering"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Snarvei til fargekorrigering"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Om fargekorrigering"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Finn ut mer om fargekorrigering"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Om fargeinvertering"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Finn ut mer om fargeinvertering"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Vis teksting"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Bare for apper som støttes"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Størrelse og stil for teksting"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Tekststørrelse <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Flere alternativer"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Tilpass størrelse og stil for teksting for å gjøre det enklere å lese den"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Disse innstillingene for teksting støttes ikke av alle medieapper"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Tilgjengelighet-knapp"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Sveip opp med to fingre fra bunnen"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Hold inne volumtastene"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Trippeltrykk på skjermen"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Fortsett"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Høreapparater"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Du kan bruke høreapparater, cochlea-implantater og andre enheter for lydforsterkning med telefonen din"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Ingen høreapparater er tilkoblet"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Legg til høreapparater"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Koble til høreapparater"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Trykk på høreapparatene dine på den neste skjermen. Du må muligens koble til venstre og høyre øre hver for seg.\n\nSørg for at høreapparatene er slått på og klare til å koble til."</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>, bare venstre"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, bare høyre"</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øyre"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> +1 til"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Koble til ny enhet"</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"Om tilkobling av nye enheter"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Høreapparater"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Lagrede enheter"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Kontroller for høreapparat"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Snarvei til høreapparat"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Kompatibilitet med høreapparater"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Forbedrer kompatibiliteten med telespoler og reduserer uønsket støy"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Om høreapparater"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Sjekk at høreapparatet ditt er slått på og klart for tilkobling"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Koble til høreapparat"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Tilgjengelige høreapparater"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Ser du ikke høreapparatet ditt?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Se flere enheter"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Lydjustering"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Lydbeskrivelse"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Hør en beskrivelse av hva som skjer på skjermen, i filmer og TV-serier som støttes"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"lydbeskrivelse, lyd, beskrivelse, nedsatt synsevne,"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Snarveien er på"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Av"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"På"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Av"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Fungerer ikke. Trykk for å få informasjon."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Denne tjenesten fungerer ikke som den skal."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Hurtigtaster for tilgjengelighet"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Vis i hurtiginnstillingene"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Rød-grønn"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Rød-grønn"</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">"Svak grønn, deuteranomali"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Svak rød, protanomali"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomali"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Ekstra dimmet"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Ekstra dimmet skjerm"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Snarvei til ekstra dimmet"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Om ekstra dimmet"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Gjør skjermen mørkere så det blir mer komfortabelt å lese"</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">"La være på etter at enheten starter på nytt"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Kort ({time} sekund)}other{Kort ({time} sekunder)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Middels ({time} sekund)}other{Middels ({time} sekunder)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Lang ({time} sekund)}other{Lang ({time} sekunder)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} sekund}other{{time} sekunder}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Innstillinger"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"På"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Av"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Forhåndsvisning"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standardvalg"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Språk"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Tekststørrelse"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Tekststil"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Tilpassede alternativer"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Bakgrunnsfarge"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Bakgrunnsopasitet"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Farge på tekstvinduet"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Opasitet for tekstvinduet"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Tekstfarge"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Tekstopasitet"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Kantfarge"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Kant-type"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Skrifttype"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Tekstingen kommer til å se slik ut"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Standard"</string>
    <string name="color_title" msgid="2511586788643787427">"Farge"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Standard"</string>
    <string name="color_none" msgid="3703632796520710651">"Ingen"</string>
    <string name="color_white" msgid="1896703263492828323">"Hvit"</string>
    <string name="color_gray" msgid="8554077329905747877">"Grå"</string>
    <string name="color_black" msgid="9006830401670410387">"Svart"</string>
    <string name="color_red" msgid="5210756997426500693">"Rød"</string>
    <string name="color_green" msgid="4400462091250882271">"Grønn"</string>
    <string name="color_blue" msgid="4997784644979140261">"Blå"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Cyan"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Gul"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Vil du gi <xliff:g id="SERVICE">%1$s</xliff:g> full kontroll over enheten din?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> må"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Fordi en app skjuler tillatelsesforespørselen, kan ikke Innstillinger bekrefte svaret ditt."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> ber om full kontroll over denne enheten. Tjenesten kan lese skjermen og handle på vegne av brukere med tilgjengelighetsbehov. Dette kontrollnivået er ikke passende for de fleste apper."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Full kontroll er passende for apper som hjelper deg med tilgjengelighetsbehov, men ikke for de fleste apper."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Se og kontroller skjermen"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Den kan lese alt innhold på skjermen og vise innhold over andre apper."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Se og utfør handlinger"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Den kan spore kommunikasjonen din med en app eller maskinvaresensor og kommunisere med apper på dine vegne."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Tillat"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Avvis"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Stopp"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Avbryt"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"Vil du stoppe <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Hvis du trykker på <xliff:g id="STOP">%1$s</xliff:g>, stoppes <xliff:g id="SERVICE">%2$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Ingen tjenester er installert"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Ingen tjeneste er valgt"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Beskrivelse ble ikke oppgitt."</string>
    <string name="settings_button" msgid="2195468788019730377">"Innstillinger"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"lyssensitivitet, fotofobi, mørkt tema, migrene, hodepine, lesemodus, nattmodus, reduser lysstyrke, hvitpunkt"</string>
    <string name="keywords_accessibility" msgid="4263443239404659143">"Brukervennlighet, enkel tilgang, assistanse, assisterende"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Vindusforstørrer, zoom, forstørring, nedsatt synsevne, forstørr, gjør større"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Teksting, teksting for hørselshemmede, CC, Transkribering, hørselshemmet, hørselstap, CART, tale til tekst, 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">"skjermstørrelse, stor skjerm"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Høy kontrast, nedsatt synsevne, fet skrift, uthevet skrift"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"juster farge"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"gjør skjermen mørk, gjør skjermen lys"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"fargekontrast"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="7151756353013736931">"motor, mus"</string>
    <string name="keywords_hearing_aids" msgid="4550504337687223314">"høreapparater, hørselshemmet, hørselstap, cochlea-implantater, enheter for lydforsterkning, lydbehandlere"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"hørselshemmet, hørselstap, teksting, fjernskriver, TTY"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="print_settings" msgid="8519810615863882491">"Utskrift"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Av"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 utskriftstjeneste er på}other{# utskriftstjenester er på}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 utskriftsjobb}other{# utskriftsjobber}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Utskriftstjenester"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Ingen tjenester er installert"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Fant ingen skrivere"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Innstillinger"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Legg til skrivere"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"På"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Av"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Legg til tjeneste"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Legg til skriver"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Søk"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Søker etter skrivere …"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Tjenesten er slått av"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Utskriftsjobber"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Utskriftsjobber"</string>
    <string name="print_restart" msgid="4424096106141083945">"Start på nytt"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Avbryt"</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">"Skriver ut <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Avbryter <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Skriverfeil <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Skriveren blokkerte <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Søkefeltet vises"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Søkefeltet er skjult"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Mer informasjon om denne skriveren"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Batteri"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Hva som har brukt batteri"</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> gjenstår"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"Batteriet er fulladet om <xliff:g id="UNTIL_CHARGED">%1$s</xliff:g>"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Lavt batteri"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"La appen kjøre i bakgrunnen"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Vil du begrense bakgrunnsaktivitet?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Hvis du begrenser bakgrunnsaktivitet for en app, kan det oppstå problemer"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Du kan ikke begrense appen siden den ikke er satt til å optimalisere batteriet.\n\nFor å begrense appen, slå på batterioptimalisering."</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Ubegrenset"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimalisert"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Begrenset"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Tillat batteribruk i bakgrunnen uten begrensninger. Dette kan bruke mer batteri."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimaliser basert på bruken din. Anbefalt for de fleste apper."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Begrens batteribruk mens appen er i bakgrunnen. Appen fungerer muligens ikke som den skal. Varsler kan bli forsinket."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Hvis du endrer hvordan en app bruker batteri, kan det påvirke ytelsen."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Denne appen krever <xliff:g id="STATE">%1$s</xliff:g> batteribruk."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"ubegrenset"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimalisert"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Finn ut mer om alternativer for batteribruk"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Skjermbruk siden batteriet var fulladet"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Batteribruk"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Loggdetaljer"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Batteribruk"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Se bruk de siste 24 timene"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Se bruk siden sist batteriet var fulladet"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Batteribruk for apper"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Bruksdetaljer"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Juster strømforbruk"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Pakker"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Appene kjører som normalt"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Batterinivået er lavt"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Slå på batterisparing for å forlenge batterilevetiden"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Forbedre batterilevetiden"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Slå på batteristyring"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Slå på batterisparing"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Batteriet kan gå tomt raskere enn vanlig"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Batterisparing er på"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Finn ut mer om batterisparing"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Noen funksjoner kan være begrenset"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Høyere batteribruk"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Se appene med høyest batteribruk"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Ladingen er optimalisert for å beskytte batteriet"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"For å forlenge batteriets levetid er ladingen optimalisert"</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"Ladingen er optimalisert for å beskytte batteriet"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"For å forlenge brukstiden for batteriet er ladingen optimalisert i dokken"</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"Ladingen er optimalisert for å beskytte batteriet"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"For å forlenge batteriets brukstid optimaliseres ladingen i dokken"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"Lader batteriet helt opp"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"For å beskytte batteriet optimaliseres ladingen neste gang nettbrettet er i dokken"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Finn ut mer om lading satt på pause"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Gjenoppta ladingen"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Inkluderer bakgrunnsaktivitet med høyt strømforbruk"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Begrens # app}other{Begrens # apper}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} er nylig begrenset}other{# apper er nylig begrenset}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} har høy batteribruk i bakgrunnen}other{# apper har høy batteribruk i bakgrunnen}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Denne appen kan ikke kjøre i bakgrunnen}other{Disse appene kan ikke kjøre i bakgrunnen}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Vil du begrense appen?}other{Vil du begrense # apper?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"For å spare batteri kan du hindre <xliff:g id="APP">%1$s</xliff:g> i å bruke batteri i bakgrunnen. Appen fungerer muligens ikke som den skal, og varsler kan bli forsinket."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"For å spare batteri kan du hindre disse appene i å bruke batteri i bakgrunnen. Begrensede apper fungerer muligens ikke som de skal, og varsler kan bli forsinket.\n\nApper:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"For å spare batteri kan hindre disse appene i å bruke batteri i bakgrunnen. Begrensede apper fungerer muligens ikke som de skal, og varsler kan bli forsinket.\n\nApper:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Begrens"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Vil du fjerne begrensningen?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Denne appen kan bruke batteri i bakgrunnen. Batteriet kan gå tomt raskere enn forventet."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Fjern"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Avbryt"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Lad til batteriet er fullt"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Problem med ladetilbehøret"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Finn ut mer om inkompatibel lading"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Batteristyring"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Administrer apper automatisk"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Når batteristyring oppdager at apper bruker for mye batteri, får du muligheten til å begrense disse appene. Begrensede apper fungerer muligens ikke som de skal, og varsler kan bli forsinket."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Begrensede apper"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Begrenser batteribruk for # app}other{Begrenser batteribruk for # apper}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Begrenset <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Disse appene er begrenset fra batteribruk i bakgrunnen. De fungerer muligens ikke som de skal, og varsler kan bli forsinket."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Bruk batteristyring"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Oppdag når apper har for høyt batteriforbruk"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Registrerer når apper har for høyt batteriforbruk"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Registrerer når apper har for høyt batteriforbruk"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# app er begrenset}other{# apper er begrenset}}"</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">"Kunne ikke lese batterimåleren."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Trykk for å finne ut mer om denne feilen"</string>
    <string name="power_screen" msgid="4596900105850963806">"Skjerm"</string>
    <string name="power_cpu" msgid="1820472721627148746">"Prosessor"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Lommelykt"</string>
    <string name="power_camera" msgid="4778315081581293923">"Kamera"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wifi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Mobilnettverk"</string>
    <string name="power_phone" msgid="2768396619208561670">"Telefonsamtaler"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Skjermbruk <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> brukt av <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> av total batteribruk"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Oversikt siden sist batteriet var fulladet"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Sist batteriet var fulladet"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Full lading varer omtrent"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Den gjenværende batteritiden er omtrentlig og kan endres basert på bruk"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Batteribruk"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Ingen bruk siden sist batteriet var fulladet"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Ingen bruk de siste 24 timene"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"siden sist batteriet var fulladet"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Systemapper"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Annet"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Anslått tid som er igjen"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Til det er fulladet"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Anslaget kan endres basert på bruk"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Medietjener"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Appoptimalisering"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Internettdeling"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Fjernede apper"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Batterisparing"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Slå på automatisk"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Ingen tidsplan"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Basert på rutinene dine"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Slås på basert på rutinene dine"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Basert på prosent"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Batterisparing slås på hvis det er sannsynlig at du går tom for batteri før det er sannsynlig at du lader neste gang"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Slås på ved <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Angi en tidsplan"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Forleng batteriets levetid"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Slå av når den er ladet"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Slå av ved <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Batterisparingen slås av når batteriet når <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">"Slå på"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Bruk batterisparing"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Slå på automatisk"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Aldri"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"med <xliff:g id="PERCENT">%1$s</xliff:g> batteri"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Batteriprosent"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Vis batteriprosenten i statusfeltet"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Batterinivå siden sist batteriet var fulladet"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Batterinivå de siste 24 timene"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Appbruk siden sist batteriet var fulladet"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Appbruk de siste 24 timene"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Systembruk siden sist batteriet var fulladet"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Systembruk de siste 24 timene"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Systembruk for <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Appbruk for <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Systembruk siden sist batteriet var fulladet, til <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Appbruk siden sist batteriet var fulladet, til <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Totalt: mindre enn ett minutt"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Bakgrunn: mindre enn ett minutt"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Skjermtid: mindre enn ett minutt"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Totalt: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Bakgrunn: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Skjermtid: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Data om batteribruk blir tilgjengelig noen timer etter at enheten er fulladet"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"nå"</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 batteribruk"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Diagram over batteribruk per dag"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Diagram over batteribruk per time"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Batteribruk siden sist batteriet var fulladet"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Batteribruk for <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Skjermtid siden sist batteriet var fulladet"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Skjermtid for <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Se etter apper"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Se etter systemer"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_cycle_count_footer" msgid="3642121059800373545">"På grunn av kvalitetskontroller før forsendelse er syklustelleren kanskje ikke null ved første gangs bruk"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Prosess-statistikk"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Nerdete statistikk om prosesser som er i gang"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Minnebruk"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> av <xliff:g id="TOTALRAM">%2$s</xliff:g> ble brukt på <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> av RAM ble brukt på <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Bakgrunn"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Forgrunn"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Bufret"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Android OS"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Innebygd"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Kernel"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Buffere"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"RAM-bruk"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"RAM-bruk (bakgrunn)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Kjøringstid"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Prosesser"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Tjenester"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Varighet"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Minnedetaljer"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 timene"</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 systemet"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Skjul systemet"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Vis prosentandeler"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Bruk Uss"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Statistikktype"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Bakgrunn"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Forgrunn"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Bufret"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Tale (inn/ut)"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Innstillinger for talekommando og -styring"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Talesøk"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Android-tastatur"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Innstillinger for taleinndata"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Taleinndata"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Taleinndatatjenester"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Full tjeneste for kommandoord og interaksjon"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Enkel tjeneste for tale til tekst"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Denne taleinndata-tjenesten kan utføre «alltid på»-taleovervåking og kontrollere taleaktiverte apper på dine vegne. Den kommer fra <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>-appen. Vil du slå på denne tjenesten?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Innstillinger for gjenkjenning på enheten"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Gjenkjenning på enheten"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Talegjenkjenning på enheten"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Foretrukket motor"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Innstillinger for motor"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Talehastighet og stemmeleie"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Motor"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Stemmer"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Talespråk"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Installer stemmer"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Fortsett til <xliff:g id="TTS_APP_NAME">%s</xliff:g>-appen for å installere stemmer"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Åpne appen"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Avbryt"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Tilbakestill"</string>
    <string name="tts_play" msgid="2945513377250757221">"Spill av"</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">"Tilpasset tilkobling"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Forlenger batterilevetiden og enhetsytelsen ved å administrere nettverkstilkoblingene automatisk"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"På"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Av"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Bruk tilpasset tilkobling"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Legitimasjonslager"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Installer et sertifikat"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Tøm legitimasjonslageret"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Fjern alle sertifikater"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Pålitelig legitimasjon"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Vis pålitelige CA-sertifikater"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Brukerlegitimasjon"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Se og endre lagret legitimasjon"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Avansert"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Legitimasjon er ikke tilgjengelig for denne brukeren"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Installert for VPN og apper"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Installert for wifi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Installert for wifi (i bruk)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Vil du fjerne alt innholdet?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Legitimasjonslageret ble tømt."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Leg.lageret kan ikke slettes."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Apper med brukstilgang"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA-sertifikat"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Brukersertifikat for VPN/app"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Wifi-sertifikat"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Dataene dine kommer ikke til å være private"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"CA-sertifikater brukes av nettsteder, apper og VPN-er til kryptering. Installer bare CA-sertifikater fra organisasjoner du stoler på. \n\nHvis du installerer et CA-sertifikat, kan sertifikateieren få tilgang til dataene dine, for eksempel passord eller kredittkortinformasjon, fra nettsteder du besøker, eller apper du bruker – selv om dataene dine er kryptert."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Ikke installer"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Installer likevel"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Sertifikatet ble ikke installert"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Vil du tillate at "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" installerer sertifikater på denne enheten?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Disse sertifikatene bekrefter identiteten din ved å dele enhetens unike ID med appene og nettadressene nedenfor"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Ikke tillat"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Tillat"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Vis flere"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"App for sertifikathåndtering"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Ingen"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Sertifikater bekrefter identiteten din når du bruker appene og nettadressene nedenfor"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Avinstaller sertifikater"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Fjern appen"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Vil du fjerne denne appen?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Denne appen kommer ikke til å administrere sertifikater, men den blir værende på enheten. Alle sertifikater som er installert av appen, blir avinstallert."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# nettadresse}other{# nettadresser}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Ringesignal for nødssituasjoner"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Velg oppførsel når en nødsamtale opprettes"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Sikkerhetskopiering"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"På"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Av"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Sikkerhetskopier og gjenopprett"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Personlige data"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Sikkerhetskopiér data"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Sikkerhetskopiér appdata, wifi-passord og andre innstillinger til Googles tjenere"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Sikkerhetskopikonto"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Administrer sikkerhetskopikontoen"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Inkluder appdata"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Auto-gjenoppretting"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Gjenopprett sikkerhetskopierte innstillinger og data når apper installeres"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Sikkerhetskopitjenesten er ikke aktiv"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Ingen konto lagrer for øyeblikket sikkerhetskopierte data"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Vil du stoppe sikkerhetskopiering av wifi-passord, bokmerker, andre innstillinger og appdata, samt slette alle kopier på Googles tjenere?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Vil du stoppe automatisk sikkerhetskopiering av enhetsdata (for eksempel wifi-passord og anropslogg) og appdata (for eksempel innstillinger og filer lagret av apper), og i tillegg slette alle kopier på eksterne tjenere?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Sikkerhetskopiér enhetsdata (for eksempel wifi-passord og anropslogg) og appdata (for eksempel innstillinger og filer lagret av apper) automatisk fra en ekstern posisjon.\n\nNår du slår på automatisk sikkerhetskopiering, lagres app- og enhetsdata automatisk fra en ekstern posisjon. Appdata kan være alle slags data apper har lagret (basert på utviklerinnstillinger), inkludert potensielle sensitive data, for eksempel kontakter, meldinger og bilder."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Innstillinger for enhetsadministrator"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Administratorapp for enheten"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Deaktiver denne administratorappen for enheten"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Avinstaller appen"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Deaktiver og avinstaller"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Apper for enhetsadministrator"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Ingen apper for enhetsadministrator er tilgjengelige"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Ingen tilgjengelige pålitelige agenter"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Vil du aktivere administratorappen?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktiver administratorappen på denne enheten"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Enhetsadministrator"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Hvis du aktiverer denne administratorappen, får appen <xliff:g id="APP_NAME">%1$s</xliff:g> tillatelse til å utføre følgende handlinger:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Denne enheten blir administrert og overvåket av <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Denne administratorappen er aktiv og gir appen <xliff:g id="APP_NAME">%1$s</xliff:g> tillatelse til å utføre følgende handlinger:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Vil du aktivere profiladministratoren?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Vil du tillate tilsyn?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Ved å fortsette blir brukeren din administrert av administratoren din, som også kan være i stand til å lagre tilknyttede data i tillegg til de personlige dataene dine.\n\nAdministratoren din kan overvåke og administrere innstillinger, tilgang, apper og data som er knyttet til denne brukeren, inkludert nettverksaktivitet og enhetens posisjonsinformasjon."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Administratoren har slått av de andre alternativene."</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Finn ut mer"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Varsellogg"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Varsellogg"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"De siste %d timene"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Slumret"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Nylig lukket"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# varsel}other{# varsler}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Anropsringetone og vibrering"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Nettverksdetaljer"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Synkronisering aktivert"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Synkronisering deaktivert"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Synkroniserer nå"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Synkroniseringsfeil."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Synkroniseringen mislyktes"</string>
    <string name="sync_active" msgid="5787407579281739975">"Synkroniserer"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Synkronisering"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Det er midlertidige problemer med synkroniseringen. Vent litt."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Legg til konto"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Jobbprofilen er ikke tilgjengelig ennå"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Jobbapper"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Slett jobbprofilen"</string>
    <string name="background_data" msgid="321903213000101158">"Bakgrunnsdata"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Apper kan når som helst synkronisere, sende og motta data"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Vil du deaktivere bakgrunnsdata?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Deaktivering av bakgrunnsdata sparer batteri og reduserer datatrafikken. Det kan hende enkelte apper fortsatt bruker tilkoblingen for bakgrunnsdata."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Synkronisering er på"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Synkronisering er av"</string>
    <string name="sync_error" msgid="846923369794727644">"Synkroniseringsfeil"</string>
    <string name="last_synced" msgid="1527008461298110443">"Sist synkronisert <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Synkroniserer nå …"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Sikkerhetskopier innstillinger"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Sikkerhetskopier innstillingene"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Synkroniser nå"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Avbryt synkronisering"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Trykk for å synkronisere nå<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">"Synkroniseringsinnstillinger for app"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Data og synkronisering"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Endre passord"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Kontoinnstillinger"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Fjern konto"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Legg til en konto"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Vil du fjerne kontoen?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Denne endringen er ikke tillatt av administratoren"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Kan ikke synkronisere manuelt"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Synkronisering for dette elementet er deaktivert. Hvis du vil endre innstillinger, kan du midlertidig slå på bakgrunnsdata og automatisk synkronisering."</string>
    <string name="delete" msgid="8330605554706263775">"Slett"</string>
    <string name="select_all" msgid="7898929601615536401">"Velg alt"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Databruk"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobildata og wifi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Autosynkroniser persondata"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Autosynkroniser jobbdata"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Endre syklus …"</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Dag i måneden for å tilbakestille databruksyklusen:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Ingen apper brukte data i denne perioden."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Forgrunn"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Bakgrunn"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"begrenset"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Vil du slå av mobildata?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Angi datagrense for mobil"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Angi datagrense for 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Angi datagrense for 2G/3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Angi datagrense for wifi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wifi"</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">"Ingen"</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">"Forgrunn:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Bakgrunn:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"App-valg"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Bakgrunnsdata"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Slå på bruk av mobildata i bakgrunnen"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Hvis du ønsker å begrense bakgrunnsdata for denne appen, må du først angi en grense for bruk av mobildata."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Vil du begrense bruken av bakgrunnsdata?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Denne funksjonen kan gjøre at apper som er avhengig av bakgrunnsdata slutter å fungere når bare  mobilnettverk er tilgjengelige.\n\nDu finner bedre egnede alternativer for databruk i appens innstillinger."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Begrensning av bakgrunnsdata er bare mulig når du har angitt en grense for mobildata."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Slå på auto-synkronisering?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Vil du slå av auto-synkronisering?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Dette gir lavere data- og batteribruk, men du må synkronisere hver konto manuelt for å hente ny informasjon. Og du får ikke varsler om oppdateringer."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Tilbakestillingsdato for brukssyklus"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Dato hver måned:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Angi"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Angi advarsel for databruk"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Angi grense for databruk"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Begrensning av databruk"</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">"grense"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Fjernede apper"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Fjernede apper og brukere"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Nettverksbruk"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Med datamåling"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Navn"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Type"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Tjeneradresse"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"PPP-kryptering (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"L2TP-passord"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"IPSec-identifikator"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Forhåndsdelt nøkkel for IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Brukersertifikat for IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"IPSec CA-sertifikat"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Tjenersertifikat for IPSec"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Vis avanserte alternativer"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"DNS-søkedomener"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"DNS-tjenere (f.eks. 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Ruter for videresending (f.eks. 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Brukernavn"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Passord"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Lagre kontoinformasjon"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(ikke brukt)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(ikke bekreft tjener)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(mottatt fra tjeneren)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Denne VPN-typen kan ikke være tilkoblet hele tiden"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"Alltid på-VPN støtter bare numeriske tjeneradresser"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"En DNS-tjener må spesifiseres for alltid på-VPN"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"DNS-tjeneradressen må være numerisk for alltid på-VPN"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Informasjonen som er angitt, støtter ikke alltid-på-VPN"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Avbryt"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Fjern"</string>
    <string name="vpn_save" msgid="683868204634860888">"Lagre"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Koble til"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Erstatt"</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">"Koble til <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Vil du koble fra dette VPN-et?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Koble fra"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Versjon"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Glem VPN-profilen"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Vil du erstatte det nåværende VPN-et?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Vil du angi alltid på-VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Når denne innstillingen er på, har du ikke internettilkobling før VPN-tilkoblingen er opprettet"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Det eksisterende VPN-et ditt blir byttet ut, og du har ikke internettilkobling før VPN-tilkoblingen er opprettet"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Du er allerede koblet til et alltid på-VPN. Hvis du kobler til et annet, blir det eksisterende VPN-et byttet ut, og alltid på-modus blir slått av."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Du er allerede koblet til et VPN. Hvis du kobler til et nytt VPN, erstattes tilkoblingen til det nåværende VPN-et."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Slå på"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"Kan ikke koble til <xliff:g id="VPN_NAME">%1$s</xliff:g>"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Denne appen støtter ikke alltid på-VPN"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Legg til VPN-profil"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Rediger profil"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Slett profil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Alltid-på-VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Ingen VPN er lagt til"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"La enheten være tilkoblet VPN hele tiden"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Støttes ikke av denne appen"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Alltid på"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Ikke sikker"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Blokkér tilkoblinger uten VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Vil du kreve VPN-tilkobling?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Ikke sikker. Oppdater til IKEv2-VPN"</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Velg en VPN-profil du vil forbli tilkoblet til. Nettverkstrafikk blir bare tillatt når du er tilkoblet denne VPN-en."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Ingen"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Alltid på-VPN krever en IP-adresse for både tjener og DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Finner ingen nettverkstilkobling. Prøv på nytt senere."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Koblet fra VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Ingen"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Et sertifikat mangler. Prøv å redigere profilen."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"System"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Bruker"</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">"Avinstaller"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Angi som pålitelig"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Vil du slå på systemets CA-sertifikat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Vil du slå av systemets CA-sertifikat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Vil du fjerne brukerens CA-sertifikat permanent?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Brukes av"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Denne oppføringen inneholder"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 brukernøkkel"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 brukersertifikat"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 CA-sertifikat"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA-sertifikater"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Legitimasjonsdetaljer"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Fjernet legitimasjon: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Ingen brukerlegitimasjon er installert"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Stavekontroll"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Stavekontroll for jobb"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Skriv inn nåværende passord for fullstendig sikkerhetskopiering her"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Skriv inn et nytt passord for fullstendig sikkerhetskopiering her"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Skriv inn det nye passordet én gang til her"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Angi passord for sikkerhetskopiering"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Avbryt"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Ytterligere systemoppdateringer"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Nettverket blir muligens overvåket"</string>
    <string name="done_button" msgid="6269449526248267">"Ferdig"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Stol på eller fjern sertifikat}other{Stol på eller fjern sertifikater}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} har installert en sertifiseringsinstans på enheten din. Dette kan gi dem tillatelse til å overvåke nettverksaktiviteten på enheten, inkludert e-poster, apper og sikre nettsteder.\n\nKontakt administratoren din for å få mer informasjon om dette sertifikatet.}other{{orgName} har installert sertifiseringsinstanser på enheten din. Dette kan gi dem tillatelse til å overvåke nettverksaktiviteten på enheten, inkludert e-poster, apper og sikre nettsteder.\n\nKontakt administratoren din for å få mer informasjon om disse sertifikatene.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} har installert en sertifiseringsinstans for jobbprofilen din. Dette kan gi dem tillatelse til å overvåke nettverksaktiviteten på jobben, inkludert e-poster, apper og sikre nettsteder.\n\nKontakt administratoren din for å få mer informasjon om dette sertifikatet.}other{{orgName} har installert sertifiseringsinstanser for jobbprofilen din. Dette kan gi dem tillatelse til å overvåke nettverksaktiviteten på jobben, inkludert e-poster, apper og sikre nettsteder.\n\nKontakt administratoren din for å få mer informasjon om disse sertifikatene.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"En utenforstående kan overvåke nettverksaktiviteten din, inkludert e-poster, apper og sikre nettsteder.\n\nPålitelig legitimasjon, som er installert på enheten din, gjør dette mulig."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Sjekk sertifikatet}other{Sjekk sertifikatene}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Flere brukere"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Brukere og profiler"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Legg til en bruker eller profil"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Begrenset profil"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Ikke konfigurert"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Ikke konfigurert – begrenset profil"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Ikke konfigurert – jobbprofil"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administrator"</string>
    <string name="user_you" msgid="3070562015202859996">"Du (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Du kan ikke legge til flere brukere. Fjern en bruker hvis du vil legge til en ny."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Begrensede profiler kan ikke legge til kontoer"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Slett <xliff:g id="USER_NAME">%1$s</xliff:g> fra denne enheten"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Innstillinger for låseskjermen"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Legg til brukere fra låseskjermen"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Bytt til administratorbruker under dokking"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Vil du slette deg selv?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Vil du slette brukeren?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Fjerne denne profilen?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Vil du slette jobbprofilen?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Alle apper og data slettes."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Hvis du fortsetter, blir alle appene og dataene i denne profilen slettet."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Alle apper og data slettes."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Legger til ny bruker …"</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Slett bruker"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Slett"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Alle apper og data i denne økten blir slettet."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Fjern"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Gjest (du)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Brukere"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Andre brukere"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Slett gjesteaktivitet"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Slett alle gjesteapper og -data når du avslutter gjestemodus"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Vil du slette gjesteaktivitet?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Apper og data fra denne gjesteøkten slettes nå, og all fremtidig gjesteaktivitet slettes hver gang du avslutter gjestemodus"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"slett, gjest, aktivitet, fjern, data, besøkende, tøm"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"La gjester ringe"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Anropsloggen deles med gjestebrukeren"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Slå på telefonsamtaler og SMS"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Gjør denne brukeren til administrator"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Slett brukeren"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Vil du slå på telefonsamtaler og SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Anrops- og SMS-loggen deles med denne brukeren."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Vil du fjerne administratorrettigheter?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Hvis du fjerner denne brukerens administratorrettigheter, kan du eller en annen administrator gi dem tilbake igjen senere."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Nødinformasjon"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Informasjon og kontakter for <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Åpne <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Tillat apper og innhold"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Apper med begrensninger"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Utvidelsesinnstillinger for appen"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Velg appene som skal installeres"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Installer tilgjengelige apper"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Kontaktløs betaling"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Standard betalingsapp"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"For å betale med en betalingsapp, hold baksiden av enheten inntil en betalingsterminal"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Finn ut mer"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Angi jobbapp som standard betalingsapp?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Slik betaler du med en jobbapp:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"Jobbprofil må være slått på."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"Du må oppgi eventuell PIN-kode, mønster eller passord til jobbprofilen."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Slik fungerer det"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Betal med telefonen i butikker"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Standardapp for betaling"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Ikke angitt"</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">"Bruk standard betalingsapp"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Bruk standard betalingsapp"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Alltid"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Unntatt når en annen betalingsapp er åpen"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"I kontaktløse terminaler betaler du med:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Betaling ved terminaler"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Konfigurer en betalingsapp. Deretter holder du baksiden av telefonen mot en terminal som har symbolet for kontaktløs betaling."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Skjønner"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Mer"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Angi en standardapp for betaling"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Oppdater standardappen for betaling"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"I kontaktløse terminaler betaler du med <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"I kontaktløse terminaler betaler du med <xliff:g id="APP_0">%1$s</xliff:g>.\n\nDette erstatter <xliff:g id="APP_1">%2$s</xliff:g> som standardappen din for betaling."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Angi som standard"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Oppdater"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Jobb"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Begrensninger"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Fjern begrensningene"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Endre PIN-koden"</string>
    <string name="help_label" msgid="2896538416436125883">"Hjelp og tilbakemelding"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Konto for innhold"</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">"Motta varsler for ekstreme trusler mot liv og eiendom"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Alvorlige trusler"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Motta varsler for alvorlige trusler mot liv og eiendom"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"AMBER Alerts"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Motta nyhetsbrev om barnebortføringer"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Gjenta"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Aktiver anropsbehandling"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Tillat denne tjenesten å styre hvilken anropsmåte som brukes."</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Anropsbehandling"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Trådløse nødvarsler"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Nettverksoperatører"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Navn på tilgangspunkt"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Avansert ringing"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"4G-ringing"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Bruk LTE-tjenester for å forbedre taleanrop (anbefales)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Bruk 4G-tjenester for å forbedre taleanrop (anbefales)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Bruk 5G for taleanrop"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Send kontakter til operatøren"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Send telefonnumrene til kontaktene dine for å levere avanserte funksjoner"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Vil du sende 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 kontakter til operatøren din?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Telefonnumrene til kontaktene dine blir med jevne mellomrom sendt til <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Denne informasjonen identifiserer hvorvidt kontaktene dine kan bruke visse funksjoner, for eksempel videosamtaler eller enkelte meldingsfunksjoner."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Telefonnumrene til kontaktene dine blir med jevne mellomrom sendt til operatøren din.<xliff:g id="EMPTY_LINE">

</xliff:g>Denne informasjonen identifiserer hvorvidt kontaktene dine kan bruke visse funksjoner, for eksempel videosamtaler eller enkelte meldingsfunksjoner."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Foretrukket nettverkstype"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (anbefales)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"MMS-meldinger"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Send og motta når mobildata er av"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Bytt mobildataoperatør automatisk"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Bruk dette nettverket når det har bedre tilgjengelighet"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Jobb-SIM-kort"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"App- og innholdstilgang"</string>
    <string name="user_rename" msgid="8735940847878484249">"GI NYTT NAVN"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Angi appbegrensninger"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Kontrollert av <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Denne appen har tilgang til kontoene dine"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Denne appen har tilgang til kontoene dine. Kontrollert av <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Wifi og mobil"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Tillat endring av Wifi- og mobilinnstillinger"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Tillat endring av Blutetooth-tilkoblinger og -innstillinger"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Posisjon"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Lar apper bruke posisjonsinformasjon"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Tilbake"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Neste"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Formater på en annen måte"</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 tilgjengelig"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Trykk for å velge SIM-kort for databruk"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Bruk alltid dette for samtaler"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Velg SIM-kort for mobildata"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Velg et SIM-kort for SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Bytter data-SIM-kort – dette kan ta opptil ett minutt …"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Vil du bruke <xliff:g id="NEW_SIM">%1$s</xliff:g> for mobildata?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Hvis du bytter til <xliff:g id="NEW_SIM">%1$s</xliff:g>, brukes ikke <xliff:g id="OLD_SIM">%2$s</xliff:g> for mobildata lenger."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Bruk <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">"Skriv inn SIM-navn"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"SIM-kortspor %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Oransje"</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-kortstatus (SIM-kortspor %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">"SIM-kort er endret."</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Trykk for å konfigurere"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Spør hver gang"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Du må velge en SIM-innstilling"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Valg av SIM-kort"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Innstillinger"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Nettverk og internett"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobil, wifi, wifi-sone"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wifi, wifi-sone"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Tilkoblede enheter"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, tilkobling"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, kjøremodus, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, kjøremodus"</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, kjøremodus, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, kjøremodus"</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">"Utilgjengelig fordi NFC er av"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Du må installere en betalingsapp for å bruke denne funksjonen"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Nylige apper, standardapper"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Tilgang til varsler er ikke tilgjengelig for apper i jobbprofilen."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Passord og kontoer"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Lagrede passord, autofyll, synkroniserte kontoer"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Standardapper"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Klonede apper"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Opprett en ny forekomst av en app, slik at du kan bruke to kontoer samtidig."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Apper som kan klones."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"<xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g> er klonet og <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g> kan klones"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Slett alle appkloner"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Kunne ikke slette alle appkloner"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Oppretter …"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Klonet"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Oppretter en klon av <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Opprettet en klon av <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Språk, bevegelser, klokkeslett, sikkerhetskopi"</string>
    <string name="languages_setting_summary" msgid="2650807397396180351">"Systemspråk, appspråk, regionsinnstillinger, tale"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, Wifi, nettverkstilkobling, Internett, trådløs, data, Wi Fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Wi‑Fi-varsel, wifi-varsel"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"databruk"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Bruk 24-timers format"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Åpne med"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Apper"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"tidssone"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Chathode, system, varsel, vindu, dialog, skjerm, over andre apper, vis"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Lommelykt, lys, lykt"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, Wifi, slå av/på, kontroll"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"mobilnett, mobil, mobiloperatør, trådløs, data, 4G, 3G, 2G, LTE"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, Wifi, ring, ringing"</string>
    <string name="keywords_display" msgid="874738809280751745">"skjerm, berøringsskjerm"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"dim skjermen, berøringsskjerm, batteri, lys"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"dim skjermen, natt, fargetone, natteendring, lysstyrke, skjermfarge, farge"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"bakgrunn, gi personlig preg, tilpass skjermen"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"tekststørrelse"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projiser, cast, skjermspeiling, skjermdeling, speiling, del skjerm, skjermcasting"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"plass, disk, harddisk, enhetsbruk"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"strømforbruk, lad"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"se batteribruk, batteribruk, strømbruk"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"batterisparing, strømsparing, sparing"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"alternativer for selvjustering, tilpasset batteri"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"stavemåte, ordliste, stavekontroll, autokorrektur"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"gjenkjenner, inndata, tale, snakk, språk, håndfri, uten hender, gjenkjenning, støtende, ord, lyd, logg, Bluetooth-hodetelefoner"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"takst, språk, standard, snakk, snakking, tekst til tale, tilgjengelighet, skjermleser, blind"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"klokke, militær"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"tilbakestill, gjenopprett, fabrikk"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"visk ut, slett, gjenopprett, tøm, fjern tilbakestill til fabrikkstandard"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"skriver"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"høyttalerpip, høyttaler, volum, kutt lyden, demp, lyd, musikk, haptisk, vibrator, vibrer"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"ikke, ikke forstyrr, forstyrr, avbrudd, pause"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"i nærheten, posisjon, logg, rapportering, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"konto, legg til en konto, jobbprofil, legg til konto, fjern, slett"</string>
    <string name="keywords_users" msgid="3497517660077620843">"begrensning, begrens, begrenset"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"tekstkorrigering, korrekt, lyd, vibrer, automatisk, språk, bevegelse, foreslå, forslag, tema, støtende, ord, type, emoji, internasjonal"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"tilbakestill, innstillinger, standard"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"apper, last ned, apper, system"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"apper, tillatelser, sikkerhet"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"apper, standard"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorer optimaliseringer, slumremodus, hvilemodus"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"krystallklar, RGB, sRGB, farge, naturlig, standard"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, oppløsning, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"farge, temperatur, D65, D73, hvit, gul, blå, varm, kjølig"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"skyv for å låse opp, passord, mønster, PIN-kode"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"én-appsmodus"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"jobbutfordring, jobb, profil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"jobbprofil, administrert profil, forene, forening, jobb, profil"</string>
    <string name="keywords_fold_lock_behavior" msgid="6278990772113341581">"vekk, sov, ikke lås, vær låst opp ved sammenlegging, sammenlegging, lukking, legg sammen, lukk, skjerm av"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"bevegelser"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"Wallet"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"betal, trykk på, betalinger"</string>
    <string name="keywords_backup" msgid="707735920706667685">"sikkerhetskopi, sikkerhetskopiér"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"bevegelse"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"ansikt, lås opp, autentisering, pålogging"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"ansikt, lås opp, autentisering, pålogging, fingeravtrykk, biometri"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, prl-versjon, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"nettverk, status for mobilnettverk, tjenestestatus, signalstyrke, mobilnettverkstype, roaming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"nettverk, status for mobilnettverk, tjenestestatus, signalstyrke, mobilnettverkstype, roaming, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"nettverk, status for mobilnettverk, tjenestestatus, signalstyrke, mobilnettverkstype, roaming, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"nettverk, status for mobilnettverk, tjenestestatus, signalstyrke, mobilnettverkstype, roaming, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"serienummer, maskinvareversjon"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"batteriinformasjon, produksjonsdato, syklusantall, første bruk"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"nivå av sikkerhetsoppdatering i Android, basisbåndversjon, kjerneversjon"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"tema, lys, mørk, modus, lyssensitivitet, fotofobi, gjør mørkere, mørkne, mørk modus, migrene"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"mørkt tema"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"Feil"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Passiv skjerm, låseskjerm"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"låseskjerm, varsel, varsler"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"ansikt"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"fingeravtrykk, legg til fingeravtrykk"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"ansikt, fingeravtrykk, legg til fingeravtrykk"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"klokkelås, legg til klokkelås"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"dim skjermen, berøringsskjerm, batteri, smart lysstyrke, dynamisk lysstyrke, automatisk lysstyrke"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"smart, ton ned skjermen, hvilemodus, batteri, tidsavbrudd, oppmerksomhet, visning, skjerm, inaktivitet"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"kamera, smart, automatisk rotasjon, rotér automatisk, rotér, vend, rotasjon, stående, liggende, retning, vertikal, horisontal"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"oppgrader, Android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"ikke forstyrr, oversikt, varsler, blokkér, demp, vibrer, hvilemodus, jobb, fokuser, lyd, kutt lyden, dag, ukedag, helg, hverdagskveld, aktivitet"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"skjerm, låsetid, tidsavbrudd, låseskjerm"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"minne, buffer, data, slett, fjern, frigjør, lagringsplass"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"tilkoblet, enhet, hodetelefoner, trådløs, koble til, øreplugger, musikk, media"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"bakgrunn, tema, rutenett, tilpass, gi personlig preg"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"ikon, markering, farge, startskjerm, låseskjerm, snarvei, klokkestø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">"innkommende varsel"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"USB-internettdeling, Bluetooth-internettdeling, wifi-sone"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"haptisk, vibrer, vibrering"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"haptisk, vibrer, skjerm, følsomhet"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"haptisk, vibrer, telefon, anrop, følsomhet, ring"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"haptisk, vibrer, telefon, anrop, ring, gradvis"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"haptisk, vibrer, følsomhet, varsel"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"haptisk, vibrer, følsomhet, alarm"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"haptisk, vibrer, følsomhet, medier"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"haptisk, vibrer, vibrering"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"batterisparing, festet, vedvarende, strømsparing, batteri"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutine, tidsplan, batterisparing, strømsparing, batteri, automatisk, prosent"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, avansert ringing, 4g-ringing"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, avansert ringing, 5g-ringing"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"Legg til språk, legg til et språk"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"tekststørrelse, stor skrift, stor skrifttype, stor tekst, nedsatt synsevne, gjør tekst større, tekstforstørrer, forstørring av tekst"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"skjermsparer som alltid er på, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"NFC, brikke, leser"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Volum, vibrasjon, ikke forstyrr"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Medievolum"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Castevolum"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Samtalevolum"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Alarmvolum"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Ringe- og varselvolum"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Ringevolum"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Varselvolum"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Stillemodus"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Vibreringsmodus"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Varsellyden er slått av – varsler vibrerer"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"<xliff:g id="VOLUME_TYPE">%1$s</xliff:g> er slått av"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Ikke tilgjengelig fordi ringelyden er kuttet"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Ringetone"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Standard varsellyd"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Lyd fra app"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Standard varsellyd"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Standard alarmlyd"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Vibrer og ring så gradvis høyere"</string>
    <string name="spatial_audio_title" msgid="1775370104206884711">"Romlig lyd"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Tastaturlyd"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Lyd for låsing av skjermen"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Lyd og vibrering ved lading"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Lyd fra dokk"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Trykke- og klikkelyder"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Vis alltid ikonet når enheten er i vibreringsmodus"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Avspilling fra dokkhøyttaler"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"All lyd"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Bare medielyd"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Stillhet"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Toner"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibrasjoner"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Lyder ved oppstart"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Direkteteksting"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Automatisk medieteksting"</string>
    <string name="spatial_audio_speaker" product="default" msgid="3956755613908467186">"Telefonhøyttalere"</string>
    <string name="spatial_audio_speaker" product="tablet" msgid="2261196916411018248">"Nettbretthøyttalere"</string>
    <string name="spatial_audio_speaker" product="device" msgid="3012868526054155189">"Enhetshøyttalere"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Hodetelefoner med ledning"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Lyd fra kompatible medier blir mer omsluttende"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Av"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"På / <xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"På / <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å slå på Romlig lyd for Bluetooth-enheter."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Innstillinger for tilkoblede enheter"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Ingen}=1{1 tidsplan er angitt}other{# tidsplaner er angitt}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Ikke forstyrr"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Bli bare varslet av viktige personer og apper"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Begrens forstyrrelser"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Slå på Ikke forstyrr"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Alarmer og medielyder kan forstyrre"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Tidsplaner"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Slett tidsplaner"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Slett"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Endre"</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">"Tidsplan"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Demp telefonen til bestemte tider"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Angi Ikke forstyrr-regler"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Tidsplan"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Bruk 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">"Tillat forstyrrelser som lager lyd"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blokkér visuelle forstyrrelser"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Tillat visuelle signaler"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Alternativer for visning av skjulte varsler"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Når «Ikke forstyrr» er på"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Ingen lydvarsling"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Du ser varsler på skjermen"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Når du mottar varsler, kommer ikke telefonen til å lage lyd eller vibrere."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Ingen lyd- eller visuell varsling"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Du verken ser eller hører varsler"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Telefonen verken viser, vibrerer for eller lager lyd for nye eller eksisterende varsler. Husk at viktige varsler om enhetsaktivitet og status fremdeles vises.\n\nNår du slår av «Ikke forstyrr», kan du finne varsler du har gått glipp av, ved å sveipe ned fra toppen av skjermen."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Tilpasset"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Slå på tilpasset innstilling"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Fjern tilpasset innstilling"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Ingen lydvarsling"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Delvis skjult"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Ingen lyd- eller visuell varsling"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Tilpassede begrensninger"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Når skjermen er på"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Når skjermen er av"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Slå av lyd og vibrering"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Ikke slå på skjermen"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Ikke blink lys"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Ikke vis varsler på skjermen"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Skjul statusfeltikoner øverst på skjermen"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Skjul varselsprikker på appikoner"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Ikke vekk for varsler"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Skjul fra nedtrekkspanelet"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Aldri"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Når skjermen er av"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Når skjermen er på"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Lyd og vibrering"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Lyd, vibrering og noen visuelle tegn fra varsler"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Lyd, vibrering og visuelle tegn fra varsler"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Varsler som er nødvendige for grunnleggende enhetsaktivitet og status, skjules aldri."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Ingen"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"andre alternativer"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Legg til"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Slå på"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Slå på nå"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Slå av nå"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Ikke forstyrr er slått på til <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Ikke forstyrr er på til du slår det av"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Ikke forstyrr ble slått på automatisk av en tidsplan (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Ikke forstyrr ble slått på automatisk av en app (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"«Ikke forstyrr» er slått på for <xliff:g id="RULE_NAMES">%s</xliff:g> med tilpassede innstillinger."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Se tilpassede innstillinger"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Bare 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">"På / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"På"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Spør hver gang"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Til du slår av"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 time}other{# timer}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minutt}other{# minutter}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Av}=1{Av / 1 tidsplan kan slås på automatisk}other{Av / # tidsplaner kan slås på automatisk}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Hva kan avbryte «Ikke forstyrr»?"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Personer"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Apper"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarmer og andre forstyrrelser"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Tidsplaner"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Varighet for hurtiginnstillinger"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Generelt"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Når «Ikke forstyrr» er på, slås lyd og vibrering av, unntatt for elementene du tillater ovenfor."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Egendefinerte innstillinger"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Gjennomgå tidsplanen"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Greit"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Varsler"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Varighet"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Meldinger, aktiviteter og påminnelser"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Når «Ikke forstyrr» er på, ignoreres meldinger, påminnelser og aktiviteter, med unntak av elementene du tillater ovenfor. Du kan justere meldingsinnstillingene for å la venner, familie eller andre kontakter nå deg."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Ferdig"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Innstillinger"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Ingen lyd- eller visuell varsling"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Ingen lydvarsling"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Du verken ser eller hører varsler. Anrop fra stjernemerkede kontakter og gjentatte oppringere tillates."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Gjeldende innstilling)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Vil du endre innstillinger for varsler for «Ikke forstyrr»?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Lyder i jobbprofilen"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Bruk lyder fra personlig profil"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Bruk de samme lydene som for den personlige profilen"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Telefonringelyd for jobb"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Standard varsellyd for jobb"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Standard alarmlyd for jobb"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Samme som den personlige profilen"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Vil du bruke lydene fra den personlige profilen?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Bekreft"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Da bruker jobbprofilen de samme lydene som den personlige profilen"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Varsler"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Varsellogg, 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">"Appvarsler"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Kontroller varsler fra enkeltapper"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Generelt"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Jobbvarsler"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Jobbprofil"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Tilpasset varselprioritet"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Angi varsler med lavere prioritet automatisk til Diskré"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Tilpasset varselrangering"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Ranger varsler automatisk etter relevans"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Tilbakemelding om tilpasset varsel"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Vis justeringer av varsler og alternativet for å gi tilbakemelding til systemet"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Tilbakestill viktighet for varsler"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Tilbakestill viktighetsinnstillinger som er endret av brukeren, og tillat at varselassistenten angir prioritet"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Foreslåtte handlinger og svar"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Vis foreslåtte handlinger og svar automatisk"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Vis nylige og slumrede varsler"</string>
    <string name="notification_history" msgid="8663811361243456201">"Varsellogg"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Bruk varselloggen"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Varselloggen er slått av"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Slå på varselloggen for å se nylige og slumrede varsler"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Ingen nylige varsler"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"De nylige og slumrede varslene dine vises her"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"se varslingsinnstillingene"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"åpne varsel"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Tillat slumring av varsler"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Varselprikk på appikoner"</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">"Lag boble for denne samtalen"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Vis flytende ikon over apper"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Vil du slå på bobler for enheten?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Hvis du slår på bobler for denne appen, slår du også på bobler for enheten.\n\nDette påvirker andre apper og samtaler som har tillatelse til å vise bobler."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Slå på"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Avbryt"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"På / samtaler kan vises som flytende ikoner"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Tillat at apper viser bobler"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Noen samtaler vises som flytende ikoner over andre apper"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Alle samtaler kan vises i bobler"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Valgte samtaler kan vises i bobler"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Ingenting 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, unntatt"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Slå av bobler for denne samtalen"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Slå på bobler for denne samtalen"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Sveip til høyre for å avvise eller til venstre for å vise menyen"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Sveip til venstre for å avvise eller til høyre for å vise menyen"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Skjul lydløse varsler i statusfeltet"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Blinkende lys"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Personvern"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Hopp over låseskjermen"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Gå rett til forrige skjerm når enheten låses opp. Varsler vises ikke på låseskjermen. Du kan se dem ved å sveipe ned fra toppen."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Låseskjerm, låseskjerm, hopp over, omgå"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Når jobbprofilen er låst"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Bare vis nye varsler på låseskjermen"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Fjern automatisk varsler som er sett, fra låseskjermen"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Varsler på låseskjermen"</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, både standard og lydløse"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Skjul lydløse samtaler og varsler"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Ikke vis noen varsler"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Sensitive varsler"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Vis sensitivt innhold når skjermen er låst"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Sensitive varsler fra jobbprofilen"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Vis sensitivt innhold fra jobbprofilen når skjermen er låst"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Vis alt innhold i varsler"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Bare vis sensitivt innhold når enheten er låst opp"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Ikke vis varsler i det hele tatt"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"Hvordan vil du vise låseskjermen?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Låseskjerm"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Vis alt innhold i jobbvarsler"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Skjul sensitivt jobbinnhold"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Hvordan vil du at profilvarsler skal vises når enheten er låst?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Profilvarsler"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Varsler"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Appvarsler"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Varselkategori"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Atferd"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Samtaler"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Samtaledel"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Tillat at appen bruker samtaledelen"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Ikke en samtale"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Fjern fra samtaledelen"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Dette er en samtale"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Legg til i samtaledelen"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Ingen prioriterte samtaler"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# prioritert samtale}other{# prioriterte samtaler}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Prioriterte samtaler"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Vis øverst i samtaledelen som flytende bobler"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"De vises øverst i samtaledelen."</string>
    <string name="other_conversations" msgid="551178916855139870">"Ikke-prioriterte samtaler"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Samtaler du har endret"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Nylige samtaler"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Fjern nylige samtaler"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Nylige samtaler er fjernet"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Samtalen er fjernet"</string>
    <string name="clear" msgid="5092178335409471100">"Fjern"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Prioriterte og endrede samtaler vises her"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Når du merker samtaler som prioritert eller endrer samtaler på andre måter, vises de her. \n\nSlik endrer du samtaleinnstillinger: \nSveip ned fra toppen av skjermen for å åpne nedtrekkspanelet, og trykk og hold på en samtale."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimer"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Vis i forgrunnen"</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">"Tillat forstyrrelser"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"La appen lage lyd, vibrere og/eller vise varsler på skjermen"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritet"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Vises øverst i samtaledelen, vises som en flytende boble, viser profilbildet på låseskjermen"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> støtter ikke de fleste samtalefunksjoner. Du kan ikke angi samtaler som prioriterte, og samtaler vises ikke som flytende bobler."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"I nedtrekkspanelet reduserer du varsler til én linje"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Ingen lyd eller vibrering"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Ingen lyd eller vibrering, og vises lavere i samtaledelen"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Kan ringe eller vibrere basert på enhetsinnstillingene"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Når enheten låses opp, vises varsler som et banner øverst på skjermen"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"«<xliff:g id="APP_NAME">%1$s</xliff:g>»: alle varsler"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"<xliff:g id="APP_NAME">%1$s</xliff:g>: alle varsler"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Omtrent # varsel per dag}other{Omtrent # varsler per dag}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Omtrent # varsel per uke}other{Omtrent # varsler per uke}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Aldri"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Enhets- og appvarsler"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Kontroller hvilke apper og enheter som kan lese varsler"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Tilgang til varsler fra jobbprofilen er blokkert"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Forbedrede varsler"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Få foreslåtte handlinger, svar med mer"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Nei"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Ingen installerte apper har bedt om tilgang til varsler."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Gi tilgang til varsler"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Forbedrede varsler erstatter tilpassede Android-varsler i Android 12. Denne funksjonen viser foreslåtte handlinger og svar og organiserer varslene dine. \n\nForbedrede varsler har tilgang til varselinnhold, inkludert personopplysninger som kontaktnavn og meldinger. Funksjonen kan også lukke og svare på varsler, for eksempel svare på anrop og kontrollere «Ikke forstyrr»."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Vil du gi tilgang til varsler for <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> får muligheten til å lese alle varsler, inkludert personopplysninger som kontaktnavn, bilder og teksten i meldinger du mottar. Appen kommer også til å kunne utsette eller avvise varsler eller bruke knapper i varsler, inkludert for å svare på telefonanrop. \n\nDette gir også appen muligheten til å slå Ikke forstyrr av eller på samt endre relaterte innstillinger."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Appen <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> får muligheten til å gjøre dette:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Lese varslene dine"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Den kan lese varslene dine, inkludert personopplysninger som kontakter, meldinger og bilder."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Svare på meldinger"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Den kan svare på meldinger og bruke knapper i varsler, blant annet slumre eller lukke varsler og svare på anrop."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Endre innstillinger"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Den kan slå Ikke forstyrr av eller på samt endre tilknyttede innstillinger."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Hvis du slår av varseltilgang for <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, kan tilgang til Ikke forstyrr også bli slått av."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Slå av"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Avbryt"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Sanntid"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Pågående kommunikasjon fra apper i bruk, navigering, telefonanrop med mer"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Samtaler"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS, tekstmeldinger og annen kommunikasjon"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Varsler"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Kan ringe eller vibrere basert på innstillingene"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Lydløs"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Varsler som aldri lager lyd eller vibrerer"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Tillatt"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Ikke tillatt"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Se alle appene"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Endre innstillinger for hver app som sender varsler"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Apper som vises på enheten"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Denne appen støtter ikke utvidete innstillinger"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Flere innstillinger"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Flere innstillinger er tilgjengelige i denne appen"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Hjelpetjenester for VR"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Ingen av de installerte appene har bedt om å bli kjørt som hjelpetjeneste for VR."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Vil du tillate tjenestetilgang for VR for <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> kan kjøres når du bruker apper i virtuell virkelighet-modus."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Når enheten er i VR-modus"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Reduser uskarphet (anbefales)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Reduser flimmer"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Bilde-i-bilde"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Ingen av de installerte appene støtter bilde-i-bilde"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"pip bilde i"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Bilde-i-bilde"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Tillat bilde-i-bilde"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"La denne appen opprette et bilde-i-bilde-vindu mens appen er åpen, eller etter at du har gått ut av den (for eksempel for å fortsette å se en video). Dette vinduet vises over andre apper du bruker."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Tilknyttede jobbapper og personlige apper"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Tilknyttet"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Ikke tilknyttet"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Ingen tilknyttede apper"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"på flere profiler tilknyttede apper jobbapper og personlige"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Tilknyttet"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Tilknytt disse appene"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Tilknyttede apper deler tillatelser og får tilgang til hverandres data."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Tilknytt apper bare hvis du stoler på at de ikke deler personlige data med IT-administratoren din."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Du kan når som helst fjerne tilknytning av apper i personverninnstillingene for enheten din."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Vil du gi jobbappen <xliff:g id="NAME">%1$s</xliff:g> tilgang til de personlige dataene dine?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Tilknytt apper bare hvis du stoler på at de ikke deler personlige data med IT-administratoren din."</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 appen har tilgang til data i den personlige <xliff:g id="NAME">%1$s</xliff:g>-appen."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Tillatelser"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Denne appen kan bruke tillatelsene til den personlige <xliff:g id="NAME">%1$s</xliff:g>-appen din, for eksempel tilgang til posisjon, lagring eller kontakter."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Ingen apper er tilknyttet"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# app er tilkoblet}other{# apper er tilkoblet}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"For å tilknytte disse appene, installer <xliff:g id="NAME">%1$s</xliff:g> i jobbprofilen din"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"For å tilknytte disse appene, installer <xliff:g id="NAME">%1$s</xliff:g> i den personlige profilen din"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Trykk for å installere appen"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"«Ikke forstyrr»-tilgang"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Kan bruke «Ikke forstyrr»"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Ingen installerte apper har bedt om «Ikke forstyrr»-tilgang"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Du har ikke tillatt varsler fra denne appen"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"I tråd med det du har valgt, blokkerer Android denne varselkategorien fra å vises på denne enheten"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"I tråd med det du har valgt, blokkerer Android denne varselgruppen fra å vises på denne enheten"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Denne appen sender ikke varsler"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategorier"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Annet"</string>
    <string name="no_channels" msgid="4716199078612071915">"Denne appen har ikke publisert noen varsler"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Flere innstillinger i appen"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# kategori er slettet}other{# kategorier er slettet}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokkér alle"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Vis aldri disse varslene"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Vis varsler"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Vis aldri varlser i panelet eller på eksterne enheter"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Tillat varsler i fullskjerm"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"La varsler fylle hele skjermen når enheten er låst"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Tillat varselprikk"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Vis varselprikk"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Overstyr «Ikke forstyrr»"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Fortsett å motta disse varslene selv om «Ikke forstyrr» er på"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Låseskjerm"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Ferdig"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Blinkende lys"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibrering"</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">"Skriv inn et navn på planen"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Tidsplannavnet er allerede i bruk"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Legg til flere"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Legg til aktivitetsplan"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Legg til tidsplan"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Velg tidsplantype"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Vil du slette regelen «<xliff:g id="RULE">%1$s</xliff:g>»?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Slett"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Du kan ikke endre disse innstillingene akkurat nå. En app (<xliff:g id="APP_NAME">%1$s</xliff:g>) har slått på Ikke forstyrr automatisk med tilpasset atferd."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Du kan ikke endre disse innstillingene akkurat nå. En app har slått på Ikke forstyrr automatisk med tilpasset atferd."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Du kan ikke endre disse innstillingene akkurat nå. Ikke forstyrr ble slått på manuelt med tilpasset atferd."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Tidspunkt"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Aktivitet"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Under aktiviteter for"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Hvilken som helst kalender"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Der svaret er"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Ja, kanskje eller ikke svart"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Ja eller kanskje"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Ja"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Fant ikke regelen."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"På / <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">"Dager"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Ingen"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Alarmer kan overstyre sluttider"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Tidsplanen slås av når en alarm ringer"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Funksjonalitet for «Ikke forstyrr»"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Bruk standardinnstillinger"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Lag egne innstillinger for denne tidsplanen"</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">"Prioriterte samtaler"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"prioriterte 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}other{# samtaler}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Hvem kan forstyrre?"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Selv om meldings- eller ringeapper ikke kan varsle deg, kan personene du velger her, fremdeles nå deg via disse appene"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Anrop"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Anrop"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"anrop"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Anrop som kan forstyrre"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"For å forsikre deg om at tillatte anrop lager lyd, sjekk at ringelyd er på for enheten"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Innkommende anrop er blokkert for «<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>». Du kan justere innstillingene for å la venner, familie eller andre kontakter nå deg."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Stjernemerkede 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}}other{{contact_1}, {contact_2} og # andre}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Uten navn)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Meldinger"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"meldinger"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Meldinger"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Meldinger som kan forstyrre"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"For å forsikre deg om at tillatte meldinger lager lyd, sjekk at ringelyd er på for enheten"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Innkommende meldinger er blokkert for «<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>». Du kan justere innstillingene for å la venner, familie eller andre kontakter nå deg."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Alle meldinger kan nå deg"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Alle anrop kan nå deg"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Ingen}=1{1 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">"Stjernemerkede 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 nedtellinger, alarmer, sikkerhetssystemer og andre apper"</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">"Lyder fra videoer, spill 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">"Berøringslyder"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Lyder fra tastaturet og andre knapper"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"berøringslyder"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Berøringslyder"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Påminnelser"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Fra oppgaver og påminnelser"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"påminnelser"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Påminnelser"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Kalenderaktiviteter"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Fra kommende kalenderaktiviteter"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"aktiviteter"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Aktiviteter"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Tillat at apper overstyrer"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Apper som kan forstyrre"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Velg flere apper"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Ingen apper er valgt"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Ingen apper kan forstyrre"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Legg til apper"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Alle varsler"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Noen varsler"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Utvalgte personer kan fremdeles nå deg, selv om du ikke tillater at apper forstyrrer"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Ingen apper kan forstyrre}=1{{app_1} kan forstyrre}=2{{app_1} og {app_2} kan forstyrre}=3{{app_1}, {app_2} og {app_3} kan forstyrre}other{{app_1}, {app_2} og # til kan forstyrre}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Apper"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Varsler som kan forstyrre"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Tillat alle varsler"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Ingenting kan forstyrre}=1{{sound_category_1} kan forstyrre}=2{{sound_category_1} og {sound_category_2} kan forstyrre}=3{{sound_category_1}, {sound_category_2} og {sound_category_3} kan forstyrre}other{{sound_category_1}, {sound_category_2} og # til kan forstyrre}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Ingenting kan forstyrre"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Ingen kan forstyrre"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Noen personer kan forstyrre"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Alle personer kan forstyrre"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Gjentatte anrop"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Tillat gjentatte anrop"</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">"stjernemerkede kontakter"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"gjentatte oppringere"</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 personen ringer om igjen innen <xliff:g id="MINUTES">%d</xliff:g> minutter"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Starttid"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Sluttid"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> neste dag"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Bytt til Bare alarmer på ubestemt tid"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Endre til bare alarmer i ett minutt frem til {time}}other{Endre til bare alarmer i # minutter frem til {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Endre til bare alarmer i én time frem til {time}}other{Endre til bare alarmer i # timer frem til {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Endre til Bare alarmer frem til <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Bytt til Alltid forstyrr"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Varsel"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Lukk"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Send tilbakemelding om enheten"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Skriv inn PIN-koden for administrator"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"På"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Av"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"På"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Av"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"På"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Av"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Festing av apper"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Med festing av apper kan du holde den aktive appen synlig til du løsner den. Denne funksjonen kan for eksempel brukes til å la en venn du stoler på, spille et bestemt spill."</string>
    <string name="screen_pinning_description" msgid="4305370471370474846">"Når en app er festet, kan den åpne andre apper, og personlige data kan være tilgjengelige. \n\nSlik bruker du festing av apper: 	\n1. Slå på festing av apper. 	\n2. Åpne Oversikt. 	\n3. Trykk på appikonet øverst på skjermen, og trykk på Fest."</string>
    <string name="screen_pinning_guest_user_description" msgid="2465729370037556955">"Når en app er festet, kan den åpne andre apper, og personlige data kan være tilgjengelige. \n\nBruk en gjestebruker i stedet hvis du vil dele enheten med noen på en sikker måte. \n\nSlik bruker du festing av apper: 	\n1. Slå på festing av apper. 	\n2. Åpne Oversikt. 	\n3. Trykk på appikonet øverst på skjermen, og trykk på Fest."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Når en app er festet \n\n•		kan personlige data være tilgjengelige \n		(f.eks. kontakter og e-postinnhold) \n•		kan den åpne andre apper \n\nBare bruk festing av apper med personer du stoler på."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Krev opplåsingsmønster for å løsne apper"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Krev PIN-kode for å løsne app"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Krev passord for å løsne apper"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Lås enheten når apper løsnes"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Bekreft sletting av SIM-kort"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Bekreft at du er deg, før du sletter et eSIM-kort"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Beta, avansert minnebeskyttelse"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Avansert minnebeskyttelse"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Denne betafunksjonen bidrar til å beskytte enheten mot feil som kan utgjøre en sikkerhetsrisiko."</string>
    <string name="memtag_on" msgid="824938319141503923">"På"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Av"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"På etter omstart"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Av etter omstart"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Foreløpig utilgjengelig for enheten"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Alltid på for enheten"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Du må starte enheten på nytt for å slå avansert minnebeskyttelse på eller av. Når det er på, kan du oppleve lavere enhetsytelse."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Vil du starte enheten på nytt?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Du må starte enheten på nytt for å slå på avansert minnebeskyttelse."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Du må starte enheten på nytt for å slå av avansert minnebeskyttelse."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Start på nytt"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Ikke nå"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Finn ut mer om avansert minnebeskyttelse."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Denne jobbprofilen administreres av:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Administrert av <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Åpne som standard"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Åpne støttede linker"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Tillat at nettlinker åpnes i denne appen"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Linker som skal åpnes i denne appen"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Støttede linker"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Andre standardinnstillinger"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Legg til en link"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"En app kan bekrefte linker som skal åpnes automatisk i appen."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# bekreftet link}other{# bekreftede linker}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Denne linken er bekreftet og åpnes automatisk i denne appen.}other{Disse linkene er bekreftet og åpnes automatisk i denne appen.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"OK"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Vis en liste over bekreftede linker"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Ser etter andre linker som støttes …"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Avbryt"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# støttet link}other{# støttede linker}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Legg til"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Åpnes 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> brukt av <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"intern lagring"</string>
    <string name="storage_type_external" msgid="125078274000280821">"ekstern lagring"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> brukt siden <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Lagringsplass som brukes"</string>
    <string name="change" msgid="273206077375322595">"Endre"</string>
    <string name="change_storage" msgid="8773820275624113401">"Endre lagringsplass"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Varsler"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"På"</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">"Av"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# kategori er slått av}other{# kategorier er slått av}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# tillatelse til}other{# tillatelser til}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Ingen tillatelser er gitt"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Ingen tillatelser er forespurt"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Kontroller apptilgang til dataene dine"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Personvernoversikt"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Vis hvilke apper som nylig har brukt tillatelser"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Ubrukte apper"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# ubrukt app}other{# ubrukte apper}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Innstillinger for ubrukte apper"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Sett appaktivitet på pause hvis ubrukt"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Fjern tillatelser, slett midlertidige filer, og stopp varsler"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Alle apper"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Installerte apper"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Instant-apper"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Slått av"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Avansert"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Behandle tillatelser"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Oppdateringer av datadeling for posisjon"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Gå gjennom apper med endringer i hvordan de deler posisjonsdata"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Trykk for å vekke"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Dobbelttrykk hvor som helst på skjermen for å vekke enheten"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Åpning av linker"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Ikke åpne støttede linker"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Åpne <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Åpne <xliff:g id="DOMAIN">%s</xliff:g> og andre nettadresser"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Tillat at appen åpner linker som støttes"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Spør hver gang"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Ikke tillat at appen åpner linker"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{Appen hevder at den håndterer # link}other{Appen hevder at den håndterer # linker}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Appen hevder at den håndterer disse linkene:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Assistent og taleinndata"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Digital assistent-app"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Standard digital assistentapp"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Godta"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Nettleserapp"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Telefonapp"</string>
    <string name="system_app" msgid="1863291702508355041">"(System)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Applagring"</string>
    <string name="usage_access" msgid="5487993885373893282">"Brukstilgang"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Tillat brukstilgang"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Skjermtid"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Med brukstilgang kan apper spore hvilke andre apper du bruker, og hvor ofte du bruker dem. Også operatør, språkinnstillinger og annen informasjon kan spores med brukstilgang."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Minne"</string>
    <string name="always_running" msgid="9012705720688200252">"Kjører alltid (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Kjører noen ganger (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Kjører sjelden (<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">"Batterioptimalisering"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Ikke optimalisert"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Ikke optimalisert"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimaliserer batteribruken"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Batterioptimalisering er ikke tilgjengelig"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Vil du la appen alltid kjøre i bakgrunnen?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"Hvis du alltid lar <xliff:g id="APP_NAME">%1$s</xliff:g> kjøre i bakgrunnen, kan det redusere batterilevetiden. \n\nDu kan endre dette senere fra Innstillinger &gt; Apper."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> er brukt siden sist batteriet var fulladet"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> bruk de siste 24 timene"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Ingen bruk av batteriet siden sist det var fulladet"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Vil du dele feilrapporten?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"IT-administratoren har bedt om en feilrapport for å hjelpe med feilsøkingen på denne enheten. Apper og data kan bli delt."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"IT-administratoren har bedt om en feilrapport for å hjelpe med feilsøkingen på denne enheten. Apper og data kan bli delt. Dette kan midlertidig gjøre enheten din tregere."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Feilrapporten blir delt med IT-administratoren. Ta kontakt med vedkommende for mer informasjon."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Del"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Avslå"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Ingen dataoverføring"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Lad den tilkoblede enheten"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Filoverføring"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Webkamera"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Konverter videoer til AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Videoer kan spilles av i flere medieavspillere, men kvaliteten kan bli redusert"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"USB-internettdeling"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Bruk USB til"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Standard USB-konfigurasjon"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Disse innstillingene gjelder når en annen enhet er koblet til og telefonen din er låst opp. Du bør bare koble til godkjente enheter."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Strømalternativer"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Alternativer for filoverføring"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"USB-innstillinger"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB kontrolleres av"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Tilkoblet enhet"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Denne enheten"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Bytter …"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Kunne ikke bytte"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Lader denne enheten"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Lading av den tilkoblede enheten"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Filoverføring"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"USB-internettdeling"</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">"Webkamera"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Filoverføring og forsyner strøm"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"USB-internettdeling og forsyner strøm"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP og forsyner strøm"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI og forsyner strøm"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Webkamera og forsyner strøm"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Bakgrunnssjekk"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Bruk tekst fra skjermen"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Gi assistentappen tilgang til skjerminnholdet som tekst"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Bruk skjermdump"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Gi assistentappen tilgang til et bilde av skjermen"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Uthev skjermen"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Uthev kantene av skjermen når assistentappen bruker tekst fra skjermen eller skjermbildet"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Assistentapper kan hjelpe deg basert på informasjon fra skjermen du bruker. Noen apper støtter tjenester for både appoversikten og taleinndata for å gi deg integrert hjelp."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Gjennomsnittlig minnebruk"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maks. minnebruk"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Minnebruk"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Appbruk"</string>
    <string name="memory_details" msgid="6133226869214421347">"Detaljer"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"<xliff:g id="SIZE">%1$s</xliff:g> gjennomsnittlig minne brukt i løpet av de siste tre timene"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Ikke noe minne brukt i løpet av de siste tre timene"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Sorter etter gjennomsnittlig bruk"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Sorter etter maks. bruk"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Ytelse"</string>
    <string name="total_memory" msgid="5244174393008910567">"Totalt minne"</string>
    <string name="average_used" msgid="690235917394070169">"Gjennomsnittlig brukt (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Ledig"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Minne brukt av apper"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 app har brukt minne i løpet av siste {time}}other{# apper har brukt minne i løpet av siste {time}}}"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Frekvens"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maks. bruk"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Ingen data er brukt"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Vil du gi tilgang til Ikke forstyrr for <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Appen kan slå av og på Ikke forstyrr og gjøre endringer i lignende innstillinger."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Må være slått på fordi varseltilgang er på"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Vil du trekke tilbake tilgangen til Ikke forstyrr for <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Alle Ikke forstyrr-regler opprettet av denne appen blir fjernet."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Ikke optimaliser"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimaliser"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Dette kan tappe batteriet ditt raskere. Appen blir ikke lenger hindret i å bruke batteri i bakgrunnen."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Anbefales for bedre batterilevetid"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Ingen"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Selv om du slår av brukstilgangen for denne appen, hindrer ikke dette administratoren din i å spore data i jobbprofilen din"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Vis over andre apper"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Vis over andre apper"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Kan vises over andre apper"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Tillat at denne appen vises over andre apper du bruker. Denne appen kan se hvor du trykker, eller endre det som vises på skjermen."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Tilgang til alle filer"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Kan administrere alle filer"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Gi denne appen tillatelse til å lese, endre og slette alle filer på denne enheten eller tilkoblede lagringsvolum. Hvis du gir appen denne tillatelsen, kan den få tilgang til filer uten at du er klar over det."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Har tilgang til alle filer"</string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Fullskjermvarsler"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Tillat fullskjermvarsler fra denne appen"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"La denne appen vise varsler som fyller hele skjermen, når enheten er låst. Apper kan bruke disse til å fremheve alarmer, innkommende anrop eller andre viktige varsler."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Apper for medieadministrering"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Tillat at appen administrerer medier"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Hvis du tillater det, kan denne appen endre eller slette mediefiler som opprettes med andre apper, uten å spørre deg. Appen må ha tilgang til filer og medier."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Medier, fil, administrering, administrator, administrer, endre, redigeringsprogram, app, applikasjon, program"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr, lyttetjeneste for virtuell virkelighet, stereo, hjelpetjenester"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Vis over andre apper"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Apper med tillatelse"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Tillatt"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Ikke tillatt"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"installer apper fra ukjente kilder"</string>
    <string name="write_settings" msgid="6864794401614425894">"Endre systeminnstillingene"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"skriv/endre systeminnstillinger"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Kan installere andre apper"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Kan endre systeminnstillingene"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Kan endre systeminnstillingene"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Endre systeminnstillingene"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Kan endre systeminnstillingene"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Med denne tillatelsen kan apper endre systeminnstillingene."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Tillat fra denne kilden"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Vri to ganger for å åpne kameraet"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Åpne kameraappen ved å vri to ganger på håndleddet"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Visningsstørrelse"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Gjør alt større eller mindre"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"skjermtetthet, zoom på skjermen, skala, skalering"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Forhåndsvisning"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Gjør mindre"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Gjør større"</string>
    <string name="disconnected" msgid="3469373726996129247">"Ikke tilkoblet"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Ikke tilkoblet"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> apper er installert"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> brukt – <xliff:g id="FREE_SPACE">%2$s</xliff:g> ledig"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Mørkt tema, skriftstørrelse, lysstyrke"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Gjennomsnittlig er <xliff:g id="USED_MEMORY">%1$s</xliff:g> av <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> minne brukt"</string>
    <string name="users_summary" msgid="8473589474976307510">"Logget på som <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Oppdatert til Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"En oppdatering er tilgjengelig"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Blokkert av jobbretningslinjer"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Kan ikke endre volumet"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Kan ikke ringe"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Kan ikke sende SMS-meldinger"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Kan ikke bruke kameraet"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Kan ikke ta skjermdumper"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Kan ikke åpne denne appen"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Blokkert av kredittleverandøren din"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Forelder kreves"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Gi telefonen til forelderen din for å starte konfigureringen av dette"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Gi telefonen til forelderen din, slik at hen kan tillate at denne innstillingen endres."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Hvis du trenger mer informasjon, bør du kontakte IT-administratoren din"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Mer informasjon"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Administratoren kan overvåke og administrere apper og data som er tilknyttet jobbprofilen din, inkludert innstillinger, tillatelser, bedriftstilgang, nettverksaktivitet og enhetens posisjonsinformasjon."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Administratoren kan overvåke og administrere apper og data som er tilknyttet denne brukeren, inkludert innstillinger, tillatelser, bedriftstilgang, nettverksaktivitet og enhetens posisjonsinformasjon."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Administratoren kan overvåke og administrere apper og data som er tilknyttet denne enheten, inkludert innstillinger, tillatelser, bedriftstilgang, nettverksaktivitet og enhetens posisjonsinformasjon."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Enhetsadministratoren din kan ha tilgang til data som er knyttet til denne enheten, kan administrere apper og kan endre enhetsinnstillingene."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Slå av"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Slå på"</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">"Wifi-sonen er aktiv"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Flymodus er på"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Nettverk er utilgjengelige"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Ikke forstyrr er på"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Lyden på telefonen er slått av"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Med unntak"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Batterisparing er på"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funksjoner er begrenset"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobildata er slått av"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internett er bare tilgjengelig via Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Datasparing"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funksjoner er begrenset"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Jobbprofilen er av"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"For apper og varsler"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Slå på lyd"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Ringelyden er kuttet"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"For anrop og varsler"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Bare vibrering"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"For anrop og varsler"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Angi tidsplanen for nattlys"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Endre skjermens fargetone automatisk hver natt"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Nattlys er på"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Skjermen har ravgul nyanse"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Gråtoner"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Bare vis i grått"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Skjul"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Kald fargetemperatur"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Bruk kaldere skjermfarger"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"For å bruke fargeendringen, slå av skjermen"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Kameraets lasersensor"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Automatiske systemoppdateringer"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Bruk oppdateringer når enheten starter på nytt"</string>
    <string name="usage" msgid="287782903846013936">"Bruk"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Bruk av mobildata"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Databruk av apper"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Wifi-databruk"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Databruk utenfor operatøren"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Ethernet-databruk"</string>
    <string name="wifi" msgid="2932584495223243842">"Wifi"</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> Wifi-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">"Datavarsel og -grense"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Brukssyklus for mobildata"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Advarsel for databruk: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"<xliff:g id="ID_1">^1</xliff:g> datagrense"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Advarsel for databruk: <xliff:g id="ID_1">^1</xliff:g> brukt, <xliff:g id="ID_2">^2</xliff:g> datagrense"</string>
    <string name="operator_warning" msgid="5672761970087591211">"Operatørens måling av databruk samsvarer ikke nødvendigvis med enhetens måling."</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Inkluderer ikke data brukt av operatørnettverk"</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> er brukt"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Angi varsel om databruk"</string>
    <string name="data_warning" msgid="2925054658166062884">"Varsel om databruk"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Måling av databruk i forbindelse med advarsler gjøres av enheten din. Disse målingene kan avvike fra operatørens data."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Angi en datagrense"</string>
    <string name="data_limit" msgid="8731731657513652363">"Datagrense"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_1">%1$s</xliff:g> brukt i perioden <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 apper som er inkludert i bruken"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 app kan bruke ubegrenset med data når Datasparing er på}other{# apper kan bruke ubegrenset med data når Datasparing er på}}"</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> er brukt"</string>
    <string name="data_overusage" msgid="3680477320458707259">"<xliff:g id="ID_1">^1</xliff:g> over grensen"</string>
    <string name="data_remaining" msgid="6316251496381922837">"<xliff:g id="ID_1">^1</xliff:g> gjenstår"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Diagram som viser databruk mellom <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">"Det finnes ingen data i denne datoperioden"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{# dag igjen}other{# dager igjen}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Ingen tid gjenstår"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Mindre enn én dag igjen"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Oppdatert av <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">"Oppdatert for <xliff:g id="ID_1">^2</xliff:g> siden"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Oppdatert av <xliff:g id="ID_1">^1</xliff:g> nå nettopp"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Oppdatert nå nettopp"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Se abonnement"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Se detaljer"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Datasparing"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Ubegrenset datatilgang"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Bakgrunnsdata er slått av"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"På"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Av"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Bruk datasparing"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Ubegrenset databruk"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Tillat ubegrenset datatilgang når Datasparing er på"</string>
    <string name="home_app" msgid="6056850504746902747">"Startsideapp"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Legg til et nytt fingeravtrykk"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Lås opp med en annen finger"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"På"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Slås på ved <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Av"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Batteribruk for apper"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Angi batteribruk for apper"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"Se innstillingene"</string>
    <string name="battery_tips_card_action_button_check" msgid="1535140204105479318">"Sjekk"</string>
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"Greit"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"Er denne meldingen nyttig?"</string>
    <string name="battery_hints_warning_icon_a11y" msgid="5312542323401447620">"Varselikon for batteritips"</string>
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Slå på tilpasset lysstyrke for å forlenge batterilevetiden"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Reduser tiden for skjermspareren for å forlenge batterilevetiden"</string>
    <string name="battery_tips_apps_summary_always_high" msgid="6334519477067044920">"<xliff:g id="APP_LABEL">%1$s</xliff:g> brukte mer batteri"</string>
    <string name="battery_tips_apps_summary_higher_than_usual" msgid="95676961671544628">"<xliff:g id="APP_LABEL">%1$s</xliff:g> brukte mer batteri enn vanlig"</string>
    <string name="battery_tips_apps_summary_always_high_in_background" msgid="2953858181710181126">"<xliff:g id="APP_LABEL">%1$s</xliff:g> brukte mer batteri da den var i bakgrunnen"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_background" msgid="1585002072567422199">"<xliff:g id="APP_LABEL">%1$s</xliff:g> brukte mer batteri enn vanlig da den var i bakgrunnen"</string>
    <string name="battery_tips_apps_summary_always_high_in_foreground" msgid="1910991243576404700">"<xliff:g id="APP_LABEL">%1$s</xliff:g> brukte mer batteri da den var i forgrunnen"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground" msgid="7937337570425168210">"<xliff:g id="APP_LABEL">%1$s</xliff:g> brukte mer batteri enn vanlig da den var i forgrunnen"</string>
    <string name="battery_app_item_hint" msgid="4850929961461039110">"Høy batteribruk"</string>
    <string name="battery_app_item_hint_in_bg" msgid="596240821466388336">"Høy batteribruk i bakgrunnen"</string>
    <string name="battery_app_item_hint_in_fg" msgid="5091860632260799910">"Høy batteribruk i forgrunnen"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Ubegrenset"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimalisert"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Begrenset"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Standard stavekontroll"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Velg stavekontroll"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Bruk stavekontroll"</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">"pkg"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"nøkkel"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"gruppe"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(sammendrag)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"offentlig versjon"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"viktighet"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"forklaring"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"kan vise merke"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"intensjon"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"slett intensjonen"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"fullskjermsintensjon"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"handlinger"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"tittel"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"eksterne innenheter"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"spesialtilpasset visning"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"diverse"</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">"et varsel er varslet"</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">"Rangeringsobjektet inneholder ikke denne tasten."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Skjermutklipp"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"skjermutklipp, hakk"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Standard for enheten"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Kunne ikke bruke overlegg"</string>
    <string name="special_access" msgid="1767980727423395147">"Spesiell apptilgang"</string>
    <string name="special_access_more" msgid="132919514147475846">"Se mer"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Lange bakgrunnsoppgaver"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Tillat bakgrunnsoppgaver som kjører lenge"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Lange bakgrunnsoppgaver"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Gi denne appen tillatelse til å kjøre lange bakgrunnsoppgaver. Dette gir appen tillatelse til å kjøre oppgaver som kan ta mer enn noen få minutter, for eksempel nedlastinger og opplastinger. \n\nHvis denne tillatelsen avslås, begrenser systemet hvor lenge appen kan utføre slike oppgaver i bakgrunnen."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"lange jobber, dataoverføring, bakgrunnsoppgaver"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Tilbakestill kallgrense for ShortcutManager API"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Frekvensberegning for ShortcutManager er tilbakestilt"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Kontroller informasjon på låseskjermen"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Vis eller skjul varselinnhold"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Tips og brukerstøtte"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Minste bredde"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Ingen installerte apper har bedt om tilgang til premium-SMS."</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Premium-SMS kan koste penger og legges til telefonregningen din. Hvis du slår på tillatelse for en app, kan du sende premium-SMS via den appen."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Tilgang til premium-SMS"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Av"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Koblet til <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Koblet til flere enheter"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Demomodus for systemgrensesnitt"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Mørkt tema"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Midlertidig slått av på grunn av Batterisparing"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Midlertidig slått av på grunn av Batterisparing"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Slå av batterisparing"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Midlertidig slått på for Batterisparing"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Prøv mørkt tema"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Bidrar til å forlenge batterilevetiden"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Hurtiginnstillingsruter for utviklere"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Slå av tidsavbrudd for adb-autorisasjon"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Slå av automatisk opphevelse av adb-autorisasjoner for systemer som ikke har koblet til igjen innen standardtiden (7 dager) eller den brukerkonfigurerte tiden (minimum 1 dag)"</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Winscope-spor"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Sensorene er av"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Innstillinger for jobbprofilen"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Søk etter kontakter i jobbkatalogen i personlige apper"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Søk og innkommende anrop kan være synlige for IT-administratoren din"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kalender for flere profiler"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Vis jobbaktiviteter i den personlige kalenderen din"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Når jobbapper er slått av, er de på pause og kan ikke sende deg varsler. Du kan heller ikke åpne dem"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Administrer lagring"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"For å frigjøre lagringsplass fjernes sikkerhetskopierte bilder og videoer fra enheten din av lagringsadministratoren."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Fjern bilder og videoer"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Lagringsadministrator"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Bruk lagringsbehandling"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Bevegelser"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Åpne kameraet raskt"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Trykk på av/på-knappen to ganger for å åpne kameraet raskt. Dette fungerer på alle skjermer."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Vend kameraet for å ta selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Navigasjonsmodus"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navigasjon med to knapper"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"For å bytte app, sveip opp på hjemknappen. For å se alle apper, sveip opp igjen. For å gå tilbake, trykk på tilbakeknappen."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Sikkerhet og nødssituasjoner"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"SOS-alarm, medisinsk informasjon, varsler"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navigasjon med bevegelser"</string>
    <string name="edge_to_edge_navigation_summary" msgid="818109176611921504">"For å gå til startsiden, sveip opp fra bunnen av skjermen. For å bytte app, sveip opp fra bunnen, hold og slipp. For å gå tilbake, sveip fra enten venstre eller høyre kant."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navigasjon med tre knapper"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Gå tilbake, gå til startsiden og bytt app med knapper nederst på skjermen."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"systemnavigasjon, navigasjon med to knapper, navigasjon med tre knapper, navigasjon med bevegelser, sveip"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digital assistent"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Sveip for å kalle opp assistenten"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Sveip opp fra et av de nederste hjørnene for å kalle opp den digitale assistenten."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Hold på hjemknappen for å åpne assistenten"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Trykk og hold inne hjemknappen for å kalle opp den digitale assistenten."</string>
    <string name="low_label" msgid="6525629096999711220">"Lav"</string>
    <string name="high_label" msgid="357503396626018487">"Høy"</string>
    <string name="left_edge" msgid="1513576842959071849">"Venstre kant"</string>
    <string name="right_edge" msgid="1505309103265829121">"Høyre kant"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Høyere følsomhet kan komme i konflikt med eventuelle appbevegelser langs kantene av skjermen."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Følsomhet for tilbakebevegelsen"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Sensitivitet for navigasjon med bevegelser"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Navigasjon med knapper"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navigasjon med bevegelser, følsomhet for tilbakebevegelsen, tilbakebevegelse"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigasjon, hjemknapp"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Enhåndsmodus"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Bruk enhåndsmodus"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Snarvei for enhåndsmodus"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"tilgjengelighet"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Sveip ned-handling"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Bruk snarveien til å"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Trekk ned den øvre halvdelen av skjermen, slik at den blir enklere å nå med én hånd"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Slik bruker du enhåndsmodus"</b>\n" • Sørg for at navigasjon med bevegelser er valgt i innstillingene for systemnavigasjon\n • Sveip ned i nærheten av bunnkanten"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Trekk skjermen ned så du når den"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Toppen av skjermen flyttes, slik at du når den med tommelen."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Vis varsler"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Varsler og innstillinger vises."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Dobbelttrykk på skjermen for å sjekke klokkeslettet, varsler og annen informasjon."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Vekk skjermen"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Trykk på skjermen for å sjekke klokkeslettet, varsler og annen informasjon."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"SOS-alarm"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Bruk SOS-alarm"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Trykk inn av/på-knappen raskt minst 5 ganger for å starte handlingene nedenfor"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Spill av nedtellingsalarmen"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Spill av en høy lyd når SOS-alarm starter"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Varsle for å få hjelp"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Ring for å få hjelp"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Nummeret du kan ringe for å få hjelp"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Trykk for å endre"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Hvis du skriver inn et nummer som ikke er et nødnummer:\n • Enheten din må være låst opp for å bruke SOS-alarm\n • Anropet ditt blir muligens ikke besvart"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Sveip fingersensoren for varsler"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Sveip på fingersensoren"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Se varsler raskt"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"På"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Av"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Oppstartsinnlasteren er allerede låst opp"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Koble til Internett, eller ta kontakt med operatøren din"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Utilgjengelig på enheter med operatørlås"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Start enheten på nytt for å slå på enhetsbeskyttelsen."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"<xliff:g id="SIZE">%1$s</xliff:g> er gjort tilgjengelig totalt\n\nSist kjørt <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Instant-apper"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Kan åpne linker i apper – selv om appene ikke er installert"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Instant-apper"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Instant Apps-innstillinger"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Installerte apper"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Lagringsplassen din blir nå administrert av lagringsadministratoren"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Kontoer for <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Synkroniser appdata automatisk"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"La apper oppdatere data automatisk"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Kontosynkronisering"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Synkronisering er slått på for <xliff:g id="ID_1">%1$d</xliff:g> av <xliff:g id="ID_2">%2$d</xliff:g> elementer"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Synkronisering er slått på for alle elementer"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Synkronisering er slått av for alle elementer"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Informasjon om administrert enhet"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Endringer og innstillinger administreres av organisasjonen din"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Endringer og innstillinger administreres av <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"For å gi tilgang til jobbdataene dine kan organisasjonen din endre innstillinger og installere programvare på enheten din.\n\nTa kontakt med administratoren for organisasjonen for mer informasjon."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Informasjonstyper organisasjonen din kan se"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Endringer utført av administratoren for organisasjonen"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Din tilgang til denne enheten"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Data som er knyttet til jobbkontoen din, for eksempel e-post og kalender"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Liste over apper på enheten din"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Tid og data som er brukt for hver app"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Den nyeste nettverkstrafikkloggen"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Den nyeste feilrapporten"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Den nyeste sikkerhetsloggen"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Ingen"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Installerte apper"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Antall apper er estimert. Det inkluderer muligens ikke apper som er installert utenfor Play-butikken."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Minimum # app}other{Minimum # apper}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Posisjonstillatelser"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Mikrofontillatelser"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Kameratillatelser"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Standardapper"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# app}other{# apper}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Standardtastatur"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Satt til <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Alltid-på VPN-er slått på"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Alltid-på-VPN er slått på i den personlige profilen din"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Alltid-på-VPN er slått på i jobbprofilen din"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Global HTTP-proxy-tjener er angitt"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Pålitelig legitimasjon"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Pålitelig legitimasjon i den personlige profilen din"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Pålitelig legitimasjon i jobbprofilen din"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Minimum # CA-sertifikat}other{Minimum # CA-sertifikater}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Administratoren kan låse enheten og tilbakestille passordet"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Administratoren kan slette alle enhetsdata"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Antall mislykkede forsøk på å oppgi passordet før alle enhetsdataene slettes"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Antall mislykkede forsøk på å oppgi passordet før jobbprofildataene slettes"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# forsøk}other{# forsøk}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Denne enheten administreres av organisasjonen din."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Denne enheten administreres av <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">"Finn ut mer"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Begrenset innstilling"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Begrensede innstillinger er tillatt for <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Av hensyn til sikkerheten er denne innstillingen utilgjengelig for øyeblikket."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Informasjon om finansiert enhet"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Kredittleverandøren din kan endre innstillinger og installere programvare på denne enheten under konfigureringen.\n\nKredittleverandøren kan låse enheten og endre enhetsinnstillingene hvis du ikke betaler avdragene.\n\nFor å finne ut mer, kontakt kredittleverandøren."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Hvis enheten din er finansiert, kan du ikke"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"installere apper fra utenfor Play-butikken"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"starte enheten din på nytt i sikker modus"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"legge til flere brukere på enheten din"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"endre dato, klokkeslett og tidssoner"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"bruke utvikleralternativer"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Kredittleverandøren din kan"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"tilgang til IMEI-nummeret ditt"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"tilbakestill enheten til fabrikkstandard hvis noe går galt"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Hvis enheten din er låst, kan du bare bruke den til å"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"starte nødanrop"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"se systeminformasjon som dato, klokkeslett, nettverksstatus og batteri"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"slå enheten din på eller av"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"se varsler og SMS-er"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"tilgang til apper som tillates av kredittleverandøren"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Når du har betalt hele beløpet:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"alle begrensninger fjernes fra enheten"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"du kan ikke avinstallere kreditorappen"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Informasjon om finansiert enhet"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Kameraapp}other{Kameraapper}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Kalender-app"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Kontakter-app"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{E-postapp}other{E-postapper}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Kart-app"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Telefonapp}other{Telefonapper}}"</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 enheten"</string>
    <string name="storage_games" msgid="1176568610086802469">"Spill"</string>
    <string name="storage_files" msgid="7968460921272772299">"Filer"</string>
    <string name="storage_images" msgid="2055893015567979387">"Bilder"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videoer"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Lyd"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Apper"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumenter og annet"</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">"Det er totalt <xliff:g id="TOTAL">%1$s</xliff:g> filer i papirkurven. Alle elementene blir slettet for godt, og du kan ikke gjenopprette 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 papirkurven"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> er brukt"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> totalt"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Fjern appen"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Vil du fjerne denne instant-appen?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Åpne"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Spill"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Lagringsplass brukt"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(avinstallert for brukeren <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(slått av for brukeren <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Autofylltjeneste"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Standard autofylltjeneste"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Passord"</string>
    <string name="credman_chosen_app_title" msgid="4547405511458518096">"Passord, passnøkler og datatjenester"</string>
    <string name="credman_credentials" msgid="4931371941253324143">"Andre leverandører"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# passord}other{# passord}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"auto, fyll, autofyll, passord"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"data, passnøkkel, passord"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"auto, fyll, autofyll, data, passnøkkel, passord"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Stoler du på denne appen?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google autofyll&gt;%1$s&lt;/xliff:g&gt; bruker det som er på skjermen, til å fastslå hva som kan fylles ut automatisk."</string>
    <string name="credman_autofill_confirmation_message" msgid="4951846866327737417">"&lt;b&gt;Vil du bruke &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; bruker det som er på skjermen din, til å avgjøre hva som kan autofylles. Nye passord, passnøkler og annen informasjon lagres her fra nå av."</string>
    <string name="credman_picker_title" msgid="2642776965060619988">"Passord, passnøkler og datatjenester"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Vil du slå av %1$s?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Vil du slå av denne tjenesten?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Lagret informasjon som passord, passnøkler, betalingsmåter og andre ting fylles ikke ut når du logger på. For å bruke informasjonen du har lagret, velg et passord, en passnøkkel eller en datatjeneste."</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Vil du bruke %1$s?"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s bruker det som er på skjermen din, for å avgjøre hva som kan autofylles."</string>
    <string name="credman_error_message_title" msgid="4741457523969373713">"Grense for passord, passnøkler og datatjenester"</string>
    <string name="credman_error_message" msgid="6793314648458925172">"Du kan ha opptil 5 passord, passnøkler og datatjenester aktive samtidig. Slå av en tjeneste for å legge til flere."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Slå av"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Autofyll"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Loggføringsnivå"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Maksimalt antall forespørsler per økt"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Maksimalt antall synlige datasett"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Tilbakestill til standardverdier"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Autofyll av utvikleralternativer er tilbakestilt"</string>
    <string name="location_category" msgid="3496759112306219062">"Posisjon"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Statusfelt for posisjonsindikator"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Vis for alle posisjoner, inkludert nettverk og tilkobling"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Bruk uavbrutt GNSS-måling"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Spor alle GNSS-konstellasjoner og -frekvenser uten målingssyklus (pulsbredde)"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Inndatametode"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Håndskrift med pekepenn"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Når det er slått på, bruker gjeldende inndatametode MotionEvent for pekepennen hvis redigering er i fokus."</string>
    <string name="device_theme" msgid="5027604586494772471">"Enhetstema"</string>
    <string name="default_theme" msgid="4815428567082263639">"Standard"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Nettverksnavn"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Vis nettverksnavn i statusfeltet"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Instant-app"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Vil du slå av lagringsadministratoren?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Oppdater «Ikke forstyrr»"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Sett varsler på pause for å holde deg fokusert"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Funksjonen er ikke tilgjengelig"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Denne funksjonen er slått av fordi den gjør telefonen din tregere"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Vis alltid krasjdialogboksen"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Vis dialogboksen hver gang en app krasjer"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Velg en ANGLE-aktivert app"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Du har ikke angitt noen ANGLE-aktivert app"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"ANGLE-aktivert app: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Innstillinger for grafikkdriver"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Endre innstillingene for grafikkdriver"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Når det finnes flere grafikkdrivere, kan du velge å bruke den oppdaterte grafikkdriveren for apper som er installert på enheten."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Aktiver for alle apper"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Velg en grafikkdriver"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Standard"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Spilldriver"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Utviklerdriver"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Systemets grafikkdriver"</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">"På forsøksstadiet: Aktiver ANGLE"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="2170215556348477481">"Varsel: Aktiver ANGLE som standard OpenGL ES-driver. Denne funksjonen er på forsøksstadiet og er muligens ikke kompatibel med enkelte kamera- og videoapper."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"En omstart kreves for å endre OpenGL ES-driveren for systemet"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Endringer av appkompatibilitet"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Slå endringer av appkompatibilitet på/av"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Endringer som er aktivert som standard"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Endringer som er deaktivert som standard"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Endringer av appkompatibilitet kan bare modifiseres for feilsøkbare apper. Installer en feilsøkbar app og prøv igjen."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Er avhengig av en annen innstilling"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Konto"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Enhetsnavn"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Grunnleggende info"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Juridisk og regelverk"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Enhetsdetaljer"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Enhetsidentifikatorer"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Wifi-kontroll"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Appen kan kontrollere wifi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Tillat at denne appen slår wifi på eller av, søker etter og kobler til wifi-nettverk, legger til eller fjerner nettverk eller starter en lokal wifi-sone"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Start via NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Tillat åpning ved NFC-skanning"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Tillat at denne appen åpnes når det skannes NFC-brikker.\nHvis denne tillatelsen er på, er appen tilgjengelig som et alternativ hver gang det registreres en brikke."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Spill av på"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Spill av <xliff:g id="LABEL">%s</xliff:g> på"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Denne enheten"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Utilgjengelig under samtaler"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Svar på anropet med"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Dette APN-et kan ikke endres."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Forhindre ringing"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Trykk på av/på og volum opp samtidig for å"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Snarvei for å forhindre ringing"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibrere"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Slå av lyden"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibrer"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Ignorer"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"For å slå på dette, endre først «Trykk og hold på av/på-knappen» til av/på-menyen."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Nettverksdetaljer"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"Enhetsnavnet ditt er synlig for apper på telefonen. Det kan også ses av andre personer når du kobler til Bluetooth-enheter, kobler til et wifi-nettverk eller konfigurerer en wifi-sone."</string>
    <string name="devices_title" msgid="649715719278562515">"Enheter"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Velg nettverk"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Frakoblet"</string>
    <string name="network_connected" msgid="7637745547242487795">"Tilkoblet"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Kobler til …"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Kunne ikke koble til"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Fant ingen nettverk."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Fant ingen nettverk. Prøv på nytt."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(forbudt)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM-kort"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Uten SIM-kort"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Ingen"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Krever SIM-kort for å koble til"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Krever <xliff:g id="WIRELESS_CARRIER">%s</xliff:g>-SIM-kort for å koble til"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Foretrukket nettverksmodus: WCDMA foretrekkes"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Foretrukket nettverksmodus: kun GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Foretrukket nettverksmodus: kun WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Foretrukket nettverksmodus: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Foretrukket nettverksmodus: CMDA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Foretrukket nettverksmodus: CMDA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Foretrukket nettverksmodus: kun CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Foretrukket nettverksmodus: kun EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Foretrukket nettverksmodus: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Foretrukket nettverksmodus: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Foretrukket nettverksmodus: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Foretrukket nettverksmodus: CDMA + LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Foretrukket nettverksmodus: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Foretrukket nettverksmodus: Global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Foretrukket nettverksmodus: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Foretrukket nettverksmodus: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Foretrukket nettverksmodus: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Foretrukket nettverksmodus: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Foretrukket nettverksmodus: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Foretrukket nettverksmodus: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Foretrukket nettverksmodus: TDSCDMA / GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Foretrukket nettverksmodus: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Foretrukket nettverksmodus: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Foretrukket nettverksmodus: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Foretrukket nettverksmodus: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Foretrukket nettverksmodus: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Foretrukket nettverksmodus: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Foretrukket nettverksmodus: bare NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Foretrukket nettverksmodus: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Foretrukket nettverksmodus: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Foretrukket nettverksmodus: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Foretrukket nettverksmodus: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Foretrukket nettverksmodus: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Foretrukket nettverksmodus: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Foretrukket nettverksmodus: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Foretrukket nettverksmodus: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Foretrukket nettverksmodus: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Foretrukket nettverksmodus: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (anbefalt)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (anbefalt)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (anbefalt)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Velg nettverk automatisk"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Operatørinnstillinger"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Konfigurer datatjeneste"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobildata"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Bruk data via mobilnettverket"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Telefonen bytter automatisk til denne operatøren når den er innen rekkevidde"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Ingen SIM-kort er tilgjengelige"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Anropsvalg"</string>
    <string name="sms_preference" msgid="7742964962568219351">"SMS-valg"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Spør hver gang"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Legg til et nettverk"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Standard for anrop"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Standard for SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Standard for anrop og SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Standard for mobildata"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Mobildata er aktiv"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobildata er slått av"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Tilgjengelig"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Legg til SIM-kort"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktiv / SIM-kort"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Inaktiv / SIM-kort"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Aktivt / eSIM-kort"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Inaktivt / eSIM-kort"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"SIM-navn og -farge"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Navn"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Farge (brukes av kompatible apper)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Lagre"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Bruk SIM-kort"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Av"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Fjern dette SIM-kortet for å deaktivere det"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Trykk for å aktivere <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Slett SIM-kort"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Foretrukket nettverkstype"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Bytt nettverksmodus"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Foretrukket nettverkstype"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Versjon av operatørinnstillinger"</string>
    <string name="call_category" msgid="641461844504128789">"Anrop"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Videoanrop via mobiloperatør"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Systemvalg"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Endre CDMA-roamingmodus"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Systemvalg"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Nettverk"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA-abonnement"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Bytt mellom 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 tillate data-roaming?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Sjekk med nettverksleverandøren din for priser."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Databruk av apper"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Ugyldig nettverksmodus (<xliff:g id="NETWORKMODEID">%1$d</xliff:g>). Ignorer."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Navn på tilgangspunkt"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"apn"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Utilgjengelig når du er koblet til <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Se flere"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Vil du slå på <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 slå på SIM-kortet?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Vil du bytte til <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Vil du bytte til å bruke SIM-kort?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Vil du bruke <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Bare ett SIM-kort kan være aktivt om gangen.\n\nSelv om du bytter til <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, blir ikke <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>-abonnementet ditt sagt opp."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="8977951796005849471">"Bare 1 eSIM-kort kan være aktivt om gangen.\n\nSelv om du bytter til <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, blir ikke <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>-abonnementet ditt sagt opp."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Bare ett SIM-kort kan være aktivt om gangen.\n\nSelv om du bytter, blir ikke <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>-abonnementet ditt sagt opp."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Du kan bruke to SIM-kort samtidig. For å bruke <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, slå av et annet SIM-kort."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Bytt 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">"Slå av <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Selv om du slår av et SIM-kort, blir ikke abonnementet ditt sagt opp"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Kobler til nettverket …"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Bytter til <xliff:g id="CARRIER_NAME">%1$s</xliff:g> for anrop og meldinger …"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"Kan ikke bytte operatør"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"Operatøren kan ikke byttes, på grunn av en feil."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Vil du slå av <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Vil du slå av SIM-kortet?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Slår av SIM-kort <xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"Kan ikke slå av operatøren"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Noe gikk galt, og enheten kunne ikke slå av operatøren."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Vil du bruke to SIM-kort?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Denne enheten kan ha to SIM-kort aktive samtidig. For å fortsette å bruke ett SIM-kort om gangen, trykk på «Nei takk»."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Vil du starte enheten på nytt?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Ja"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Start på nytt"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Nei takk"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Avbryt"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Bytt"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Kan ikke aktivere SIM-kortet"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Prøv å slå på SIM-kortet igjen. Start enheten på nytt hvis problemet vedvarer."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Aktivering av nettverk"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Operatørbytte"</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">"Trykk for å oppdatere SIM-kortinnstillingene"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Byttet til <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Byttet til en annen operatør"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Mobilnettverket ditt er endret"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Konfigurer det andre SIM-kortet ditt"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Velg det aktive SIM-kortet ditt, eller bruk to SIM-kort samtidig"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Velg nummeret du vil bruke"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{1 nummer er tilgjengelig på denne enheten, men bare ett kan brukes om gangen}=2{2 numre er tilgjengelige på denne enheten, men bare ett kan brukes om gangen}other{# numre er tilgjengelige på denne enheten, men bare ett kan brukes om 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">"Kunne ikke aktiveres nå"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Vil du bruke <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> brukes til mobildata, anrop og SMS."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Ingen aktive SIM-kort er tilgjengelige"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"For å bruke mobildata, ringefunksjoner og SMS senere, gå til nettverksinnstillingene"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM-kort"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Vil du slette dette eSIM-kortet?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Hvis du sletter dette SIM-kortet, fjernes <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g>-tjenesten fra denne enheten.\n\n<xliff:g id="CARRIER_NAME_B">%1$s</xliff:g>-tjenesten blir ikke sagt opp."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Slett"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Sletter SIM-kortet …"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"Kan ikke slette SIM-kortet"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"Dette SIM-kortet kan ikke slettes, på grunn av en feil.\n\nStart enheten på nytt og prøv igjen."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Koble til enheten"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"Appen <xliff:g id="APPNAME">%1$s</xliff:g> vil bruke et midlertidig wifi-nettverk for å koble til enheten din"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Fant ingen enheter. Sørg for at enhetene er slått på og tilgjengelige for tilkobling."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Prøv på nytt"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Noe dukket opp. Appen har kansellert forespørselen om å velge en enhet."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Tilkoblingen var vellykket"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Kunne ikke koble til"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Vis alle"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Søker etter enheten …"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Kobler til enheten …"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Venstre"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Høyre"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Etui"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Innstillinger-panel"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Tvungen skrivebordsmodus"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Tvungen eksperimentell skrivebordsmodus på sekundære skjermer"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Slå på apper som ikke kan endre størrelse, i flervindusmodus"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Tillater apper som ikke kan endre størrelse, i flervindusmodus"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Overstyr tving mørk"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Overstyrer tving mørk-funksjonen til å være alltid på"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Personvern"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Tillatelser, kontoaktivitet, personlige data"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Kontroller"</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 forslaget?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Du har lite lagringsplass. <xliff:g id="PERCENTAGE">%1$s</xliff:g> er brukt – <xliff:g id="FREE_SPACE">%2$s</xliff:g> er ledig"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Send tilbakemelding"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Vi du gi oss en tilbakemelding om dette forslaget?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> er kopiert til utklippstavlen."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Bruk av Tilgjengelighet"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 app har full tilgang til enheten}other{# apper har full tilgang til enheten}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Viktig informasjon"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"FORTSETT"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NEI TAKK"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Posisjon"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Operatøren din kan samle inn posisjonen din når du bruker denne tjenesten for nødanrop.\n\nSe personvernreglene til operatøren for mer informasjon."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Du kan miste tilgang til gjenværende tid eller data. Sjekk med leverandøren din før fjerning."</string>
    <string name="content_capture" msgid="868372905432812238">"Appinnhold"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Tillater at apper sender innhold til Android-systemet"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Samle inn minnedump fra systemet"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Memory Tagging Extension"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Med Memory Tagging Extension (MTE) blir det lettere å finne minnerelaterte sikkerhetsproblemer i appen og gjøre appens integrerte kode sikrere."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Hvis du slår på MTE, kan enheten bli tregere."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Finn ut mer om MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Slå på MTE til du slår den av igjen"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Du må starte enheten på nytt for å slå på MTE."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Du må starte enheten på nytt for å slå av MTE."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Slå på MTE for én økt"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Systemet starter på nytt, og du kan eksperimentere med Memory Tagging Extension (MTE). MTE kan ha negativ innvirkning på systemets ytelse og stabilitet. Dette tilbakestilles ved neste omstart."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Start systemet på nytt for å slå på MTE for én økt"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"MTE er slått på allerede"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Samler inn minnedump fra systemet"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Kunne ikke samle inn minnedump for systemet"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Samle automatisk inn minnedumper fra systemet"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Samle automatisk inn en minnedump for Android-systemet når det bruker for mye minne"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Koble fra"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Nødanrop"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Nødanrop via wifi-anrop støttes ikke av operatøren din.\nEnheten bytter automatisk til et mobilnettverk for å foreta et nødanrop.\nNødanrop er bare mulige i områder med mobildekning."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Bruk Wi‑Fi for anrop for å forbedre kvaliteten"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Reserve for anrop"</string>
    <string name="backup_calling_setting_summary" msgid="599493254305348733">"Hvis <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> er utilgjengelig eller roamer, bruker du SIM-kortet for mobildata for <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g>-anrop."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"reserve for anrop"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Innkommende MMS-melding"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Kan ikke sende MMS-meldinger"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Trykk for å tillate MMS-meldinger på <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> når mobildata er av"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"MMS-melding"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Det oppsto et problem med kombinasjonen av SIM-kort"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Funksjonaliteten kan begrenses hvis du bruker <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g>. Trykk for å finne ut mer."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Kombinasjon av SIM-kort"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Informasjon om jobbretningslinjene dine"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Innstillingene administreres av IT-administratoren din"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Feilrapporthåndtering"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Fastslår hvilken app som håndterer Feilrapport-snarveien på enheten din."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Personlig"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Jobb"</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 valget er ikke gyldig lenger. Prøv på nytt."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Trykk og hold av/på-knappen"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Trykk og hold på av/på-knappen for å åpne"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Av/på-meny"</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">"Åpne den digitale assistenten"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Åpne av/på-menyen"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Du må angi en skjermlås for å bruke denne funksjonen"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Av/på-meny:\nTrykk på av/på-knappen og volum opp-knappen samtidig"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Forhindre ringing:\nTrykk på en volumknapp for å bruke snarveien"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Varighet for trykk og hold"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Juster følsomheten ved å velge hvor lenge av/på-knappen skal holdes inne"</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">"Lang"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Vis Wallet"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Gi tilgang til lommeboken fra låseskjermen"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Vis QR-kodeskanneren"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Gi tilgang til QR-kodeskanneren fra låseskjermen"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Vis enhetsstyring"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Fra låseskjermen"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Bruk enhetskontroller"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"For å bruke, slå først på «Vis enhetsstyring»"</string>
    <string name="lockscreen_double_line_clock_summary" msgid="4109235686687860393">"Klokkens størrelse endres basert på innholdet på låseskjermen"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Dynamisk klokke"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Snarveier"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="one"><xliff:g id="FIRST_0">%1$s</xliff:g></item>
    </plurals>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"Vil du slå av VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Dette slår også av 5G-tilkoblingen din.\nUnder taleanrop kan du ikke bruke internett, og noen apper fungerer muligens ikke."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Sperr kjøring midlertidig for bufrede apper"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Utløper aldri."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Leieperioden utløper aldri."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Tillat skjermoverlegg over Innstillinger"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Tillat apper som kan vises over andre apper, å legge seg over Innstillinger-skjermer"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Tillat Mock Modem"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Tillat at denne enheten kjører Mock Modem-tjenesten for instrumenteringstesting. Ikke slå på dette under normal bruk av telefonen"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Medier"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Fest medieavspilleren"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"For å gjenoppta avspilling raskt holdes medieavspilleren åpen i hurtiginnstillingene"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Vis medier på låseskjermen"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Medieavspilleren vises fortsatt på låseskjermen, slik at du kan gjenoppta avspillingen raskt"</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Vis medieanbefalinger"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Basert på aktiviteten din"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Skjul spilleren"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Vis spilleren"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"medier"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth slås på"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internett"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM-kort"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Anrop og SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Wifi-anrop"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Ring og motta anrop via Wi‑Fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Anrop"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"foretrukket"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"foretrekkes for anrop"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"foretrekkes for SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"utilgjengelig"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Midlertidig utilgjengelig"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Uten SIM-kort"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Nettverksinnstillinger"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"nettverkstilkobling, internett, trådløs, data, wifi, wi-fi, wi fi, mobilnett, mobil, mobiloperatør, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Vil du tilbakestille internett?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Tilbakestiller internettforbindelser …"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Fiks tilkobling"</string>
    <string name="networks_available" msgid="3299512933684383474">"Tilgjengelige nettverk"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"For å bytte nettverk, koble fra Ethernet"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"W+-tilkoblinger"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Tillat at Google Fi bruker W+-nettverk for å forbedre hastighet og dekning"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"W+-nettverk"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"eSIM-kort"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"eSIM-kort"</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 for <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"anrop"</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 å forbedre brukeropplevelsen på enheten kan apper og tjenester søke etter wifi-nettverk når som helst – også når wifi er slått av. Dette kan for eksempel brukes til å forbedre posisjonsbaserte funksjoner og tjenester. Du kan endre dette i innstillingene for wifi-skanning."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Endre"</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">"Tilkoblet"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Koblet til midlertidig"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Bruker <xliff:g id="SUBNAME">%1$s</xliff:g> midlertidig"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Ingen tilkobling"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Mobildata kobler ikke til automatisk"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Vil du slå av mobildata?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Du får ikke tilgang til data eller internett via <xliff:g id="CARRIER">%s</xliff:g>. Internett er bare tilgjengelig via Wifi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"operatøren din"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Ikke tillatt av organisasjonen din"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Utilgjengelig fordi sengetidsmodus er på"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Tilbakestilling av viktighet for varsler er fullført."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Apper"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"En enhet vil ha tilgang til meldingene dine. Trykk for å se mer informasjon."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Vil du gi tilgang til meldinger?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"En Bluetooth-enhet, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, vil ha tilgang til meldingene dine.\n\nDu har ikke koblet til <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> tidligere."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"En enhet vil ha tilgang til kontaktene dine og samtaleloggen din. Trykk for å se mer informasjon."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Vil du gi tilgang til kontaktene og samtaleloggen?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"En Bluetooth-enhet, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, vil ha tilgang til kontaktene dine og samtaleloggen din. Dette inkluderer data om innkommende og utgående anrop.\n\nDu har ikke koblet til <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> tidligere."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Lysstyrke"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Lås skjermen"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Utseende"</string>
    <string name="category_name_color" msgid="937514550918977151">"Farge"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Andre skjermkontroller"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Generelt"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Bruk mørkt tema"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Bruk Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Bruk «Forhindre ringing»"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Bruk wifi-sone"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Bruk festing av apper"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Bruk utvikleralternativer"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Bruk utskriftstjeneste"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Tillat flere brukere"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"tillat, flere, bruker, tillatelse, mange"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Bruk trådløs feilsøking"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Bruk innstillinger for grafikkdriver"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Bruk nattlys"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Bruk NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Bruk tilpasset lysstyrke"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Bruk Wi‑Fi-anrop"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Se alle appene"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Smart viderekobling"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Smart viderekobling er slått på"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Smart viderekobling er slått av"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Anropsinnstillinger"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Oppdaterer innstillingene …"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Feil med samtaleinnstillinger"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Nettverks- eller SIM-kortfeil."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"SIM-kortet er ikke aktivert."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Skriv inn telefonnumrene"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Skriv inn telefonnummeret"</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">"Tillat 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G er mindre sikkert, men kan gi deg bedre tilkobling noen steder. 2G tillates alltid for nødanrop."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> krever at 2G er tilgjengelig"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Krev kryptering"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Kryptering er sikrere, men du kan muligens ikke koble til enkelte steder. Kryptering kreves aldri for nødanrop"</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Alle tjenester"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Vis tilgang til utklippstavlen"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Vis en melding når apper bruker tekst, bilder eller annet innhold du har kopiert"</string>
    <string name="all_apps" msgid="3054120149509114789">"Alle apper"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Ikke tillat"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultrabredbånd (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Bidrar til å finne den relative posisjonen til enheter i nærheten som har UWB"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Slå av flymodus for å bruke UWB"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB er tilgjengelig på dette stedet"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Kameratilgang"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Mikrofontilgang"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"For apper og tjenester"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"For apper og tjenester. Hvis denne innstillingen er av, kan mikrofondata fremdeles deles når du ringer et nødnummer."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Forrige"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Neste"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Forhåndsvisning av farge"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Forespørsel om tilgang til SIM-kort"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"En enhet vil ha tilgang til SIM-kortet ditt. Trykk for å se mer informasjon."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Vil du gi tilgang til SIM-kortet?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"En Bluetooth-enhet, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, vil ha tilgang til data fra SIM-kortet ditt. Dette inkluderer kontaktene dine.\n\nNår <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> er tilkoblet, mottar enheten alle anrop til <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"En Bluetooth-enhet er tilgjengelig"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"En enhet vil koble til. Trykk for å se mer informasjon."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Vil du koble til Bluetooth-enheten?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> vil koble til denne telefonen.\n\nDu har ikke koblet til <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> tidligere."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Ikke koble til"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Koble til"</string>
    <string name="tare_settings" msgid="3788654800004869077">"TARE-innstillinger"</string>
    <string name="tare_on" msgid="2386073225978684535">"På"</string>
    <string name="tare_off" msgid="6305694402929756726">"Av"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Tilbakestill til standardinnstillingene"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Tilbakestilt til standardinnstillingene."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Maksimum saldo når enheten er fulladet"</string>
    <string name="tare_balances" msgid="731881382594747961">"Saldoer"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Forbruksgrenser"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Grense for første forbruk"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Minimumsgrense for forbruk"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Maksimumsgrense for forbruk"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modifikatorer"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Handlinger (kostnad for å produsere)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Handlinger (grunnpris)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Belønninger per enkelthendelse"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Belønninger per sekund hendelsesvarighet"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Maksimalt antall belønninger per dag"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Appinstallering"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Høyeste aktivitet"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Varsel er sett"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Varsel er sett innen 15 minutter"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Interaksjon med varsel"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Modulinteraksjon"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Annen brukerinteraksjon"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Jobb starter med maksimum prioritet"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Jobb kjører med maks prioritet"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Jobb starter med høy prioritet"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Jobb kjører med høy prioritet"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Jobb starter som standard"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Jobb kjører som standard"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Jobb starter med lav prioritet"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Jobb kjører med lav prioritet"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Jobb starter med minimum prioritet"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Jobb kjører med minimum prioritet"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Straff for jobbtidsavbrudd"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Minimum saldo når enheten er fulladet (fritatt)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Minimum saldo når enheten er fulladet (hodeløs systemapp)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Minimum saldo når enheten er fulladet (gjenværende apper)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Tillegg til minimumsaldo når enheten er fulladet (oppdateringsverktøy for apper)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Lading"</item>
    <item msgid="658627268149681677">"Slumremodus"</item>
    <item msgid="1599558140284643834">"Strømsparingsmodus"</item>
    <item msgid="588427840913221601">"Prosesstilstand"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Bekreft"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Forhåndsvis"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Velg en skjermsparer"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Vis tilleggsinformasjon"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Vis ting som klokkeslettet, været eller annen informasjon på skjermspareren"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Vis hjemkontroller"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Vis knappen for hjemkontroller på skjermspareren"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Flere innstillinger"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Velg en skjermsparer"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Velg hva du ser på skjermen når nettbrettet er i dokken. Enheten kan bruke mer energi når en skjermsparer brukes."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Tilpass"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Tilpass <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"En omstart kreves for å slå på støtte for fritt format."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"En omstart kreves for å tvinge skrivebordmodus på sekundære skjermer."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Start på nytt nå"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Start på nytt senere"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Romlig lyd"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Lyd fra kompatible enheter blir mer omsluttende"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Hodesporing"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Lyden endres når du beveger hodet, slik at den høres mer naturlig ut"</string>
    <string name="bluetooth_details_permissions_sync_title" msgid="584337314155926373">"Synkroniser tillatelser"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="3426601558010545762">"Gi <xliff:g id="REMOTE_DEVICE_NAME">%1$s</xliff:g> de samme apptillatelsene som du har gitt på <xliff:g id="LOCAL_DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Type lydenhet"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"Ukjent"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Høyttaler"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Hodetelefoner"</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">"Bilsett"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Annet"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Grense for nedlastingshastighet for nettverket"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Konfigurer grensen for innkommende båndbredde i nettverket, som benyttes for alle nettverk som gir internettilkobling."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Konfigurer grensen for nedlastingshastighet for nettverket"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Ingen grense"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Slå av begrensninger for underordnede prosesser"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Slå av begrensningene for hvor mange systemressurser som kan brukes av underordnede approsesser"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Tving aktivering av Notater-rollen"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Aktiver systemintegreringer for notater via Notater-rollen. Hvis Notater-rollen er aktivert allerede, skjer det ingenting. Krever omstart."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Kringkast"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Kringkast <xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Lytt til kringkastinger som spilles av i nærheten"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Kringkast medier til enheter i nærheten, eller lytt til andres kringkastinger"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Kringkastinger"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Lytter til"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Finn kringkastinger"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Forlat kringkastingen"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Skann QR-koden"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Skriv inn passordet"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Kan ikke koble til. Prøv på nytt."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Feil passord"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Kan ikke bli med i kringkastingen"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"For å begynne å lytte, midtstill QR-koden nedenfor"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"QR-koden er ikke i et gyldig format"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Konverter til eSIM-kort"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Overfør eSIM-kortet til en annen enhet"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# app}other{# apper}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Apper installert i bakgrunnen"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Enhetsprodusenten kan installere apper på enheten i bakgrunnen eller gi operatøren din og andre partnere tillatelse til å gjøre det.\n\nApper som er oppført her, kreves ikke for at enheten skal fungere som normalt. Du kan avinstallere apper du ikke vil ha."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Ingen apper er installert i bakgrunnen"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Avinstaller app"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Apper installert den siste måneden}other{Apper installert de siste # månedene}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Apper installert for mer enn # måned siden}other{Apper installert for mer enn # måneder siden}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Høyde/bredde-forhold"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Hvis ikke denne appen er laget for å passe til <xliff:g id="DEVICE_NAME">%1$s</xliff:g>, kan du prøve et nytt høyde/bredde-forhold for å se appen."</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Hvis ikke denne appen er laget for å passe til <xliff:g id="DEVICE_NAME">%1$s</xliff:g>, kan du prøve et nytt høyde/bredde-forhold for å se appen. Enkelte apper er kanskje ikke optimalisert for visse høyde/bredde-forhold."</string>
    <string name="aspect_ratio_summary_text" msgid="4737461467467220325">"Hvis en app ikke er laget for å passe til <xliff:g id="DEVICE_NAME">%1$s</xliff:g>, kan du prøve et nytt høyde/bredde-forhold for å se appen"</string>
    <string name="aspect_ratio_main_summary_text" msgid="5544816872094235840">"Hvis en app ikke er laget for å passe til <xliff:g id="DEVICE_NAME">%1$s</xliff:g>, kan du prøve et nytt høyde/bredde-forhold for å se appen. Enkelte apper er kanskje ikke optimalisert for visse høyde/bredde-forhold."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Foreslåtte apper"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Endrede apper"</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"Appstandard"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Fullskjerm"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Halv skjerm"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Høyde/bredde-forhold for enheten"</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> av <xliff:g id="DENOMINATOR">%2$s</xliff:g>"</string>
    <string name="app_aspect_ratio_footer" msgid="4029509301182067475">"Appen starter på nytt når du endrer høyde/bredde-forholdet. Du kan miste endringer som ikke er lagret. Enkelte apper er kanskje ikke optimalisert for visse høyde/bredde-forhold."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Høyde/bredde-forhold (på forsøksstadiet)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Høyde/bredde-forhold (eksperiment)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Høyde/bredde-forhold (prøvefunksjoner)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"På forsøksstadiet"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Eksperiment"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Prøvefunksjoner"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Fingeravtrykkssensor"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Blitsvarsler"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Om blitsvarsler"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Av"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"På / kamerablits"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"På / skjermblink"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"På / kamerablits og skjermblink"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Få kameralyset eller skjermen til å blinke når du mottar varsler, eller når alarmer utløses"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Få skjermen til å blinke når du mottar varsler, eller når alarmer utløses"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Hvis du er lysfølsom, bør du være forsiktig med å bruke blitsvarsler"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"blits, lys, hørshelshemmet, hørselstap"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Forhåndsvisning"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Kamerablits"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Skjermblink"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Farge for skjermblink"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Blå"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Asurblå"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Cyan"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Vårgrønn"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Grønn"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Gulgrønn"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Gul"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Oransje"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Rød"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Rosa"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Magenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Fiolett"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Ferdig"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Avbryt"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Kontrast"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Standard"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Middels"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Høy"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Denne appen kan bare åpnes i ett vindu"</string>
</resources>
