<?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">"Nee"</string>
    <string name="create" msgid="986997212165228751">"Skep"</string>
    <string name="allow" msgid="3763244945363657722">"Laat toe"</string>
    <string name="deny" msgid="7326117222944479942">"Weier"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Skakel aan"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Onbekend"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Tik om inligting te wys"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Jy het nou # stap oor voordat jy ’n ontwikkelaar is.}other{Jy het nou # stappe oor voordat jy ’n ontwikkelaar is.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Jy is nou \'n ontwikkelaar!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Toemaar, jy is reeds \'n ontwikkelaar."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Aktiveer asseblief eers ontwikkelaaropsies."</string>
    <string name="dev_settings_available_to_admin_only_warning" msgid="3408243404879083111">"Net die admingebruikers het toegang tot ontwikkelaarinstellings."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Stelsel"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"In diens"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Diens is nie beskikbaar nie"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio is af"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Swerwing"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Swerf nie"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Ontkoppel"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Koppel"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Gekoppel"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Afgelas"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Onbekend"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Voorskou"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Maak kleiner"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Maak groter"</string>
    <string name="stay_awake_on_fold_title" msgid="6590454679898134221">"Altyd"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"Boonste skerm skakel aan wanneer jy jou toestel vou"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Slegs speletjies, video’s en meer"</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"Boonste skerm skakel aan vir apps wat keer dat jou skerm onaktief word"</string>
    <string name="stay_awake_on_lockscreen_title" msgid="8088456642083051068">"Swiep op om voort te gaan"</string>
    <string name="stay_awake_on_lockscreen_summary" msgid="2299351813382522952">"Vou jou foon en swiep op die boonste skerm op om voort te gaan om die app te gebruik, of wag ’n paar sekondes vir die skerm om te sluit"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Nooit"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"Boonste skerm sluit wanneer jy jou toestel vou"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Gebruik outodraai"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"Gesigbespeuring gebruik die voorste kamera om die akkuraatheid van outodraai te verbeter. Prente word nooit geberg of na Google toe gestuur nie."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Sigbaar vir alle nabye Bluetooth-toestelle (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Sigbaar vir alle Bluetooth-toestelle wat naby is"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Nie sigbaar vir ander Bluetooth-toestelle nie"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Net sigbaar vir saamgebinde toestelle"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Bluetooth-toestelle"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Toestelnaam"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Hernoem hierdie toestel"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Hernoem"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Ontkoppel toestel?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Bind nuwe toestel saam"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_screen_auto_on_title" msgid="8496443490064988240">"Skakel dit môre outomaties weer aan"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Bind regteroor saam"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Bind linkeroor saam"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Bind jou ander oor saam"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Jou linkergehoortoestel is gekoppel.\n\nMaak seker dat jou regtergehoortoestel aangeskakel en gereed is om saam te bind wanneer jy dit wil saambind."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Jou regtergehoortoestel is gekoppel.\n\nMaak seker dat jou linkergehoortoestel aangeskakel en gereed is om saam te bind wanneer jy dit wil saambind."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Bind regteroor saam"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Bind linkeroor saam"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Vir alle beskikbare gehoortoestelle"</string>
    <!-- no translation found for bluetooth_device_controls_title (659009912978022189) -->
    <skip />
    <!-- no translation found for bluetooth_device_controls_summary (5387400497394163925) -->
    <skip />
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Vir hierdie toestel"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Oudio-uitvoer"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Meer oor oudio-uitvoer"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Roeteer klanke na jou gehoortoestel of foon se luidspreker"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Soortgelyk"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Luitoon en wekkers"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Oudio tydens oproepe"</string>
    <string name="bluetooth_media_title" msgid="2878373577382067290">"Media- en stelselklanke"</string>
    <string name="bluetooth_notification_title" msgid="8708962394926222039">"Kennisgewings"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Oudio-uitvoer word by verstek deur individuele apps bepaal"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Onbenoemde Bluetooth-toestel"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Soek"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Geen Bluetooth-toestelle is naby gevind nie."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Bluetooth-saambindingsversoek"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Saambindingsversoek"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Tik om met <xliff:g id="DEVICE_NAME">%1$s</xliff:g> saam te bind."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth is af"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Tik om dit aan te skakel"</string>
    <string name="device_picker" msgid="2427027896389445414">"Kies Bluetooth-toestel"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> wil Bluetooth aanskakel"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> wil Bluetooth afskakel"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"\'n Program wil Bluetooth aanskakel"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"\'n Program wil Bluetooth afskakel"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Skakel tans Bluetooth af…"</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Skakel tans Bluetooth af…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Bluetooth-verbindingsversoek"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Telefoonboek-toegangversoek"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Boodskaptoegangversoek"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Vir ander toestelle sigbaar as \"<xliff:g id="DEVICE_NAME">^1</xliff:g>\""</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Skakel Bluetooth aan om aan ander toestelle te koppel."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Jou toestelle"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Bind nuwe toestel saam"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Deaktiveer Bluetooth-A2DP-hardeware-aflaai"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Deaktiveer Bluetooth LE Audio-hardewareoordrag"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Herbegin toestel?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Jy moet jou toestel herbegin om hierdie instelling te verander."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Herbegin"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Kanselleer"</string>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Deaktiveer Bluetooth LE-oudio"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Deaktiveer Bluetooth LE oudio-kenmerk as die toestel LE oudiohardewarevermoëns ondersteun."</string>
    <string name="bluetooth_leaudio_mode" msgid="5206961943393400814">"Bluetooth LE-oudiomodus"</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Wys LE-oudiowisselaar in Toestelbesonderhede"</string>
    <string name="bluetooth_bypass_leaudio_allowlist" msgid="7392319491894565552">"Omseil Bluetooth LE-oudiotoelaatlys"</string>
    <string name="bluetooth_bypass_leaudio_allowlist_summary" msgid="8999245286359656738">"Gebruik LE-oudio by verstek, selfs as LE-oudio se randtoestel nie geverifieer is vir voldoening aan toelaatlyskriteria nie."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Mediatoestelle"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Oproeptoestelle"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Ander toestelle"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Gestoorde toestelle"</string>
    <string name="connected_device_fast_pair_device_title" msgid="543124539265592392">"Word met rekening geassosieer"</string>
    <string name="connected_device_previously_associated_fast_pair_device_title" msgid="8353405823992023457">"Voorheen met rekening gebruik"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Bluetooth sal aangeskakel word om saam te bind"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Verbindingvoorkeure"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Voorheen gekoppel"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth is aangeskakel"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Sien alles"</string>
    <string name="connected_device_fast_pair_device_see_all" msgid="4898279230458128620">"Sien alles"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Stilus"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Puntknoppiedruk"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (werkprofiel)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Skryf in teksvelde"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Ignoreer alle stilusknoppiedrukke"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Stilus"</string>
    <string name="audio_streams_empty" msgid="8803517701437394982">"Geen oudiostroom is gevind nie."</string>
    <string name="date_and_time" msgid="1788358029823431692">"Datum en tyd"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Instaanbediener"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Maak skoon"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Instaanbediener-poort"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Omseil instaanbediener vir"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Herstel verstekke"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Klaar"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Instaanbediener-gasheernaam"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Aandag"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"Die gasheernaam wat jy ingevoer het, is nie geldig nie."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"Die uitsluitingslys wat jy ingevoer het, is nie behoorlik geformateer nie. Voer asseblief \'n kommageskeide lys uitgeslote domeine in."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Jy moet die poortveld voltooi."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"Die poortveld moet leeg wees as die gasheerveld leeg is."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"Die poort wat jy ingevoer het, is nie geldig nie."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"Die HTTP-instaanbediener word deur die blaaier gebruik, maar kan nie deur die ander programme gebruik word nie."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"PAC-URL: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Pieng gasheernaam(www.google.com) IPv4:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"HTTP-kliënttoets:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Doen piengtoets"</string>
    <string name="skip_label" msgid="6380034601349015895">"Slaan oor"</string>
    <string name="next_label" msgid="1248293387735652187">"Volgende"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Tale"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Voorkeurtaalvolgorde"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Stelseltaal"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Verwyder"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Voeg \'n taal by"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Taal"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Voorkeurtaal"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Apptale"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Stel die taal vir elke program"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Programtaal"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Voorgestelde tale"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Alle tale"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Stelseltaal"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Stelselverstek"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"Taalkeuse vir hierdie program is nie in Instellings beskikbaar nie."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Taal kan verskil van tale wat in die program beskikbaar is. Sommige programme steun dalk nie hierdie instelling nie."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Stel die taal vir elke app."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"Jou stelsel, programme en webwerwe gebruik die eerste gesteunde taal uit jou voorkeurtale."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Gaan na programtaalinstellings vir elke program om ’n taal te kies."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Kom meer te wete oor apptale"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Verander stelseltaal na %s ?"</string>
    <string name="title_system_locale_addition" msgid="8218683660751479466">"Voeg %s by voorkeurtale?"</string>
    <string name="desc_system_locale_addition" msgid="3409917362651596070">"Dit laat apps en webwerwe weet dat jy ook hierdie taal verkies."</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Jou toestelinstellings en streeksvoorkeure sal verander."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Verander"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s is nie beskikbaar nie"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Hierdie taal kan nie as ’n stelseltaal gebruik word nie, maar jy het apps en webwerwe ingelig dat jy hierdie taal verkies."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Streeksvoorkeure"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Stel eenheid- en nommervoorkeure"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Lig apps in oor jou streekvoorkeure sodat hulle jou ervaring kan personaliseer."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Apps sal waar moontlik jou streekvoorkeure gebruik."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatuur"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Eerste dag van die week"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Nommervoorkeure"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Gebruik verstek"</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">"Sondag"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Maandag"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Dinsdag"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Woensdag"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Donderdag"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Vrydag"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Saterdag"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"As ’n app nie streeksvoorkeure steun nie, sal die app sy versteklocale-instellings gebruik."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Kom meer te wete oor taalvoorkeure."</string>
    <string name="category_title_terms_of_address" msgid="4309422700380895278">"Bykomende voorkeure"</string>
    <string name="terms_of_address_title" msgid="4064593634733842458">"Aanspreekvorms"</string>
    <string name="terms_of_address_summary" msgid="6136134336560679144">"Stel hoe jy aangespreek wil word"</string>
    <string name="terms_of_address_intro_title" msgid="6149691509414243483">"Apps kan jou aanspreekvorms gebruik om te personaliseer hoe hulle jou aanspreek."</string>
    <string name="terms_of_address_not_specified" msgid="4439257779351251973">"Nie gespesifiseer nie"</string>
    <string name="terms_of_address_feminine" msgid="1743479869695539283">"Vroulik"</string>
    <string name="terms_of_address_masculine" msgid="983106046135098856">"Manlik"</string>
    <string name="terms_of_address_neutral" msgid="5475414185543112478">"Neutraal"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Verwyder geselekteerde taal?}other{Verwyder geselekteerde tale?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Teks sal in \'n ander taal gewys word."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Kan nie alle tale verwyder nie"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Hou minstens een voorkeurtaal"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Nie beskikbaar as stelseltaal nie"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Skuif op"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Skuif af"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Skuif na bo"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Skuif na onder"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Verwyder taal"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Kies aktiwiteit"</string>
    <string name="cancel" msgid="5780102414089664898">"Kanselleer "</string>
    <string name="okay" msgid="4827099303045669054">"OK"</string>
    <string name="forget" msgid="3754013654135912783">"Vergeet"</string>
    <string name="save" msgid="3125033126936493822">"Stoor"</string>
    <string name="done" msgid="7497982645646431310">"Klaar"</string>
    <string name="apply" msgid="7834684883190163536">"Pas toe"</string>
    <string name="share" msgid="8502235338607613795">"Deel"</string>
    <string name="add" msgid="8335206931421683426">"Voeg by"</string>
    <string name="remove" msgid="1028414219245072102">"Verwyder"</string>
    <string name="settings_label" msgid="943294133671632976">"Instellings"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Instellings"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Instellingskortpad"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Vliegtuigmodus"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Draadloos en netwerke"</string>
    <string name="roaming" msgid="3055365654530847985">"Swerwing"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Verbind aan datadienste tydens swerf"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Verbind aan datadienste tydens swerf"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Swerwingheffings kan geld."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Stel tyd outomaties"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Stel outomaties"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Ligging sal gebruik word om die tydsone te stel wanneer hierdie wisselaar aan is"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Gebruik verstek vir locale"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Gebruik 24-uur-formaat"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Tyd"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Tydformaat"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Tydsone"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Kies tydsone"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Datum"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Soek streek"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Streek"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Kies UTC-afwyking"</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">"Gebruik <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> begin op <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Gebruik <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Geen somertyd nie."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Dagligbesparingstyd"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Standaardtyd"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Kies volgens streek"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Kies volgens UTC-afwyking"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Sluit ná skermuitteltyd"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> ná uitteltyd"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Onmiddellik ná uitteltyd, tensy <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> dit ontsluit hou"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> ná uitteltyd, behalwe as <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> dit ontsluit hou"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Voeg teks by op sluitskerm"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Geen"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Bv. Joe se Android."</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Ligging"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Gebruik ligging"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Af"</string>
    <string name="location_settings_summary_location_on" msgid="4273299717586679786">"{count,plural, =1{Aan / # app het toegang tot ligging}other{Aan / # apps het toegang tot ligging}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Laai tans …"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Programme met die Toestelle in die Omtrek-toestemming kan die relatiewe posisie van gekoppelde toestelle bepaal."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"Liggingtoegang is af vir programme en dienste. Jou toestelligging kan steeds aan nooddienste gestuur word wanneer jy \'n noodnommer bel of \'n SMS daarheen stuur."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="349380666660145540">"Kom meer te wete oor ligginginstellings"</string>
    <string name="location_settings_tooltip_text_for_chrome" msgid="3574930966097093550">"Om liggingtoegang te verander, gaan na Instellings &gt; Sekuriteit en Privaatheid &gt; Privaatheidkontroles."</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Rekeninge"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Sekuriteit"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Enkripsie en eiebewyse"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Sluitskerm"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Wat om te wys"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Nie beskikbaar nie"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Sekuriteitstatus"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Skermslot, Kry My Toestel, appsekuriteit"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Sekuriteit en privaatheid"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Appsekuriteit, toestelslot, toestemmings"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Gesig is bygevoeg"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Opstelling is nodig"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Gesigslot"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Gesigslot vir werk"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Hoe om Gesigslot op te stel"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Stel Gesigslot op"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Gebruik jou gesig om te staaf"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Begin"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"As toeganklikheid-Gesigslot afgeskakel is, sal sommige opstellingstappe dalk nie behoorlik met TalkBack werk nie."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Gaan terug"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Gaan aan met opstelling"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Gebruik toeganklikheidopstelling"</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">"Kanselleer"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"Nee, dankie"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Ek stem in"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Meer"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Ontsluit met jou gesig"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Laat Gesigslot toe"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Gebruik jou gesig om te staaf"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Gebruik jou gesig om jou foon te ontsluit of aankope goed te keur.\n\nLet wel: Jy kan nie jou gesig gebruik om hierdie toestel te ontsluit nie. Kontak jou organisasie se administrateur vir meer inligting."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Gebruik jou gesig om jou foon te ontsluit, aankope te magtig, of by programme aan te meld"</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">"Sentreer jou gesig in die sirkel"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Slaan oor"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Jy het die maksimum aantal gesigte bygevoeg"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Kan nie meer gesigte byvoeg nie"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"Inskrywing is nie voltooi nie"</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">"Tydlimiet vir gesiginskrywing is bereik. Probeer weer."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"Gesiginskrywing het nie gewerk nie."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Gereed. Lyk goed."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Klaar"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Verbeter Gesigslot se werkverrigting"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Stel Gesigslot weer op"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Stel Gesigslot weer op"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Verbeter sekuriteit en werkverrigting"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Stel Gesigslot op"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Vee jou huidige gesigmodel uit om Gesigslot weer op te stel.\n\nJou gesigmodel sal permanent en veilig uitgevee word.\n\nNadat dit uitgevee is, sal jy jou PIN, patroon of wagwoord moet hê om jou foon te ontsluit of vir stawing in apps."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Vee jou huidige gesigmodel uit om Gesigslot weer op te stel.\n\nJou gesigmodel sal permanent en veilig uitgevee word.\n\nNadat dit uitgevee is, sal jy jou vingerafdruk, PIN, patroon of wagwoord moet hê om jou foon te ontsluit of vir stawing in apps."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Gebruik Gesigslot:"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Wanneer jy Gesigslot gebruik"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Vereis dat oë oop moet wees"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Jou oë moet oop wees om die foon te ontsluit"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Vereis altyd bevestiging"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Vereis altyd bevestigingstap as Gesigslot in apps gebruik word"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Vee gesigmodel uit"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Stel Gesigslot op"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Vee gesigmodel uit?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Jou gesigmodel sal permanent en veilig uitgevee word. \n\nNadat dit uitgevee is, sal jy jou PIN, patroon of wagwoord nodig hê om jou foon te ontsluit of vir stawing in apps."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Jou gesigmodel sal permanent en veilig uitgevee word. \n\nNadat dit uitgevee is, sal jy jou PIN, patroon of wagwoord nodig hê om jou foon te ontsluit."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Jou gesigmodel sal permanent en veilig uitgevee word.\n\nNadat dit uitgevee is, sal jy jou vingerafdruk, PIN, patroon of wagwoord nodig hê om jou foon te ontsluit of vir stawing in apps."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Jou gesigmodel sal permanent en veilig uitgevee word.\n\nNadat dit uitgevee is, sal jy jou vingerafdruk, PIN, patroon of wagwoord nodig hê om jou foon te ontsluit."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Gebruik Gesigslot om jou foon te ontsluit"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Vingerafdruk"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Vingerafdruk"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Wanneer Vingerafdrukslot gebruik word"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Vingerafdruk vir werk"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Voeg vingerafdruk by"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Vingerafdruk is bygevoeg}other{# vingerafdrukke is bygevoeg}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Opstelling is nodig"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Stel jou vingerafdruk op"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Laat vingerafdrukslot toe"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Gebruik jou vingerafdruk"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Kom meer te wete oor Vingerafdrukslot"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Jy is in beheer"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Jy en jou kind is in beheer"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Hou in gedagte"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Gebruik jou vingerafdruk om jou foon te ontsluit of aankope goed te keur.\n\nLet wel: Jy kan nie jou vingerafdruk gebruik om hierdie toestel te ontsluit nie. Gebruik jou organisasie se administrateur vir meer inligting."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Kanselleer"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Nee, dankie"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Ek stem in"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Slaan vingerafdruk oor?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"Vingerafdrukopstelling neem net \'n minuut of twee. As jy dit oorslaan, kan jy jou vingerafdruk later in instellings byvoeg."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Wanneer jy dié ikoon sien, moet jy jou vingerafdruk vir stawing gebruik, soos wanneer jy by programme aanmeld of \'n aankoop goedkeur"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Hou in gedagte"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Hoe dit werk"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"Vingerafdrukslot skep \'n unieke model van jou vingerafdruk om te verifieer dis jy. Jy sal jou vingerafdruk uit verskillende posisies afneem om hierdie vingerafdrukmodel tydens opstelling te skep."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"Vingerafdrukslot skep \'n unieke model van jou kind se vingerafdruk om te verifieer dis hy of sy. Jou kind sal sy of haar vingerafdruk uit verskillende posisies afneem om hierdie vingerafdrukmodel tydens die opstelling te skep."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Gebruik vir die beste resultate ’n skermbeskermer wat Gemaak vir Google-gesertifiseer is. Jou vingerafdruk sal dalk nie met ander skermbeskermers werk nie."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Gebruik vir die beste resultate ’n skermbeskermer wat Gemaak vir Google-gesertifiseer is. Jou kind se vingerafdruk sal dalk nie met ander skermbeskermers werk nie."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Horlosieontsluiting"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="5032953826653108646">"Wanneer jy Gesigslot en Vingerafdrukslot opstel, sal jou foon vir jou vingerafdruk vra wanneer jy ’n masker dra of in die donker is.\n\nHorlosieontsluiting is nog ’n gerieflike manier om jou foon te ontsluit, byvoorbeeld wanneer jou vingers nat is of jou gesig nie herken word nie."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="5881355884547769337">"Horlosieontsluiting is nog ’n gerieflike manier om jou foon te ontsluit, byvoorbeeld wanneer jou vingerafdruk nie herken word nie."</string>
    <string name="biometric_settings_intro_with_face" msgid="7671919122230588521">"Horlosieontsluiting is nog ’n gerieflike manier om jou foon te ontsluit, byvoorbeeld wanneer jou gesig nie herken word nie."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Gebruik vingerafdruk of horlosie om te"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Gebruik gesig of horlosie om te"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Gebruik gesig, vingerafdruk of horlosie om te"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Gebruik horlosie om te"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Gebruik gesig of horlosie"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Gebruik vingerafdruk of horlosie"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Gebruik gesig, vingerafdruk of horlosie"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Gebruik horlosie"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Stel eers Gesig- of Vingerafdrukslot op"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Jy kan met jou horlosie ontsluit wanneer jou gesig of vingerafdruk nie herken word nie"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Stel eers Vingerafdrukslot op"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Jy kan met jou horlosie ontsluit wanneer jou vingerafdruk nie herken word nie"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Stel eers Gesigslot op"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Jy kan met jou horlosie ontsluit wanneer jou gesig nie herken word nie"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Stel op"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Vingerafdruk en <xliff:g id="WATCH">%s</xliff:g> is bygevoeg"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Vingerafdrukke en <xliff:g id="WATCH">%s</xliff:g> is bygevoeg"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Gesig en <xliff:g id="WATCH">%s</xliff:g> is bygevoeg"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Gesig, vingerafdruk en <xliff:g id="WATCH">%s</xliff:g> is bygevoeg"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Gesig, vingerafdrukke en <xliff:g id="WATCH">%s</xliff:g> is bygevoeg"</string>
    <string name="security_settings_remoteauth_preference_title" msgid="8319680328086089533">"Remote Authenticator-ontsluiting"</string>
    <string name="security_settings_remoteauth_preference_summary" msgid="1507004469316635196">"Horlosie is bygevoeg"</string>
    <string name="security_settings_remoteauth_enroll_introduction_title" msgid="2151004795778999671">"Stel jou horlosie op"</string>
    <string name="security_settings_remoteauth_enroll_introduction_message" msgid="8737276885766036074">"Horlosieontsluiting is nog ’n gerieflike manier waarop jy hierdie foon kan ontsluit; byvoorbeeld, wanneer jou vingers nat is of jou gesig nie herken word nie.\n\nJy kan jou horlosie gebruik om hierdie foon te ontsluit wanneer jy:"</string>
    <string name="security_settings_remoteauth_enroll_introduction_disagree" msgid="7639258097401796028">"Nie nou nie"</string>
    <string name="security_settings_remoteauth_enroll_introduction_agree" msgid="5271119227172049339">"Gaan voort"</string>
    <string name="security_settings_remoteauth_enroll_introduction_more" msgid="1644105894631257595">"Meer"</string>
    <string name="security_settings_remoteauth_enroll_introduction_how_title" msgid="6604152528267830349">"Hoe dit werk"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_lock_open" msgid="8570511335628725116">"Jou horlosie moet ontsluit, om jou pols en binne bereik van hierdie foon wees. Jy hoef jou horlosie nie weer te ontsluit terwyl dit om jou pols is nie."</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_notifications" msgid="4298855831154039694">"Jy sal op jou horlosie in kennis gestel word wanneer hierdie foon ontsluit word. Tik op die kennisgewing om die foon weer te sluit as jy dit onbedoeld ontsluit het."</string>
    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title" msgid="7974976673323638524">"Jy is in beheer"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_remove_watch" msgid="1888318677088986801">"Jy kan jou horlosie enige tyd in Instellings uit Horlosieontsluiting verwyder"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_tap_notification" msgid="1597397399097952974">"Tik op ’n kennisgewing"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_swipe_up" msgid="2129230804324634653">"Swiep boontoe op die sluitskerm"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_title" msgid="313016997943607675">"Kies jou horlosie"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_list_heading" msgid="8227585438932911013">"Beskikbare horlosies"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_disagree" msgid="1670201454188049863">"Kanselleer"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_agree" msgid="7048336252635730908">"Bevestig"</string>
    <string name="security_settings_remoteauth_enroll_finish_title" msgid="3807372930755413112">"Jy is gereed!"</string>
    <string name="security_settings_remoteauth_enroll_finish_description" msgid="4876209907275244653">"Jy kan nou jou horlosie gebruik om hierdie foon te ontsluit wanneer jy op die sluitskerm boontoe swiep of op ’n kennisgewing tik"</string>
    <string name="security_settings_remoteauth_enroll_finish_btn_next" msgid="8072138423143889592">"Klaar"</string>
    <string name="security_settings_remoteauth_settings_title" msgid="1564912618737165129">"Horlosieontsluiting"</string>
    <string name="security_settings_remoteauth_settings_description" msgid="2758239650119457964">"Jy kan jou horlosie gebruik om hierdie foon te ontsluit wanneer jy op die sluitskerm boontoe swiep of op ’n kennisgewing tik"</string>
    <string name="security_settings_remoteauth_settings_info_footer" msgid="795894033901478120">"Om Horlosieontsluiting te gebruik, moet jou horlosie ontsluit, om jou pols, binne bereik en aan hierdie foon gekoppel wees. As die verbinding onderbreek word, sal jy die foon moet ontsluit voordat jy Horlosieontsluiting kan gebruik.\n\nHou in gedagte:\nJy kan net een horlosie op ’n slag opgestel hê. Om ’n ander horlosie by te voeg, moet jy eers die huidige een verwyder."</string>
    <string name="security_settings_remoteauth_settings_learn_more" msgid="5653556124819260050">"Kom meer te wete oor Horlosieontsluiting"</string>
    <string name="security_settings_remoteauth_settings_register_new_authenticator" msgid="9191331738306527887">"Voeg horlosie by"</string>
    <string name="security_settings_remoteauth_settings_remove_device" msgid="2436226120578851282">"Verwyder horlosie"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Gesig- en vingerafdrukslot"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Gesig- en Vingerafdrukslot vir werk"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Opstelling is nodig"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Gesig en vingerafdrukke is bygevoeg"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Gesig en vingerafdruk is bygevoeg"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Wanneer jy Gesigslot en Vingerafdrukslot opstel, sal jou foon vir jou vingerafdruk vra as jy \'n masker dra of op \'n donker plek is"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Maniere om te ontsluit"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Gebruik gesig of vingerafdruk en:"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Ontsluit jou foon"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Verifieer dat dit jy is in apps"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Gebruik gesig"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Gebruik vingerafdruk"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Gebruik gesig of vingerafdruk"</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 nie Gesigslot opstel nie"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Verlaat verdeelde skerm om Gesigslot op te stel"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Kan nie vingerafdruk opstel nie"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Verlaat verdeelde skerm om Vingerafdrukslot op te stel"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"OK"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Slaan skermslot oor?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Slaan in elk geval oor"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Gaan terug"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Slaan oor"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Kanselleer"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Raak die sensor"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Raak die aan/af-skakelaar sonder om dit te druk"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Hoe om jou vingerafdruk op te stel"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Dit is op die agterkant van jou foon. Gebruik jou wysvinger."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"Die vingerafdruksensor is op jou skerm. Jy sal jou vingerafdruk op die volgende skerm vasvang."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Begin"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Beweeg jou vinger oor die skerm om die sensor te kry. Raak en hou die vingerafdruksensor."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Illustrasie met toestel en ligging van vingerafdruksensor"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Naam"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"Goed"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Probeer weer"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Vee uit"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Raak die sensor"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Plaas jou vinger op die sensor en lig dit op wanneer jy \'n vibrasie voel"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Hou jou vingerafdruk plat op die sensor totdat jy \'n vibrasie voel"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Hou jou vingerafdruk op die sensor totdat jy ’n vibrasie voel sonder om die knoppie te druk.\n\nSkuif jou vinger elke keer effens. Dit help om meer van jou vingerafdruk vas te vang."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Raak en hou die vingerafdruksensor"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Lig en raak dan weer"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Nog een keer"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Volg die vingerafdrukikoon"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Hou aan om jou vinger op te lig om die verskillende dele van jou vingerafdruk by te voeg"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Raak en hou elke keer wanneer die vingerafdrukikoon skuif. Dit help om meer van jou vingerafdruk vas te vang."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Plaas jou vingerpunt op die sensor"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Plaas jou vinger se linkerrand"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Plaas jou vinger se regterrand"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Plaas die middelste deel van jou vinger op die sensor"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Plaas jou vingerpunt op die sensor"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Plaas die linkerkant van jou vinger op die sensor"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Ten einde, plaas die regterkant van jou vinger op die sensor"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Plaas die kant van jou vingerafdruk op die sensor en hou; ruil dan om na die ander kant"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Dit help om meer van jou vingerafdruk vas te vang"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Inskrywing van vingerafdruk is op <xliff:g id="PERCENTAGE">%d</xliff:g> persent"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"<xliff:g id="PERCENTAGE">%d</xliff:g> persent ingeskryf"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Skryf tans vingerafdruk in <xliff:g id="PERCENTAGE">%d</xliff:g> persent"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Vingerafdruk bygevoeg"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Raak om enige tyd te ontsluit"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Raak die sensor om te ontsluit, selfs terwyl die skerm af is. Dit kan onbedoelde ontsluiting veroorsaak."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Skerm, ontsluit"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Doen dit later"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Lig en raak dan weer"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Plaas die kant van jou vingerafdruk op die sensor en hou; ruil dan om na die ander kant"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Slaan vingerafdrukopstelling oor?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Jy het gekies om jou vingerafdruk te gebruik as een manier om jou foon te ontsluit. As jy dit nou oorslaan, sal jy dit later moet opstel. Dit neem net \'n minuut of wat om op te stel."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Slaan opstelling oor vir <xliff:g id="OPTIONS">%s</xliff:g>?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Slaan PIN-opstelling oor?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Slaan opstelling vir PIN en gesig oor?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Slaan opstelling vir PIN en vingerafdruk oor?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Slaan opstelling vir PIN, gesig en vingerafdruk oor?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Slaan wagwoordopstelling oor?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Slaan opstelling vir wagwoord en gesig oor?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Slaan wagwoord- en vingerafdrukopstelling oor?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Los wagwoord-, gesig- en vingerafdrukopstelling?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Slaan patroonopstelling oor?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Slaan opstelling vir patroon en gesig oor?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Slaan patroon- en vingerafdrukopstelling oor?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Los patroon-, gesig- en vingerafdrukopstelling?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Stel skermslot op"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Klaar"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Oeps, dis nie die sensor nie"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Raak sensor op die agterkant van jou foon. Gebruik jou wysvinger."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Kan nie vingerafdrukopstelling voltooi nie"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Jy kan nou weer probeer of jou vingerafdruk later in Instellings opstel."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Jy kan nou weer probeer of jou vingerafdruk later opstel."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Vingerafdrukopstelling het uitgetel"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Jy kan jou vingerafdruk later in Instellings opstel."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Iets het skeefgeloop. Jy kan jou vingerafdruk later in Instellings opstel."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Jy kan jou vingerafdruk later opstel."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Iets het skeefgeloop. Jy kan jou vingerafdruk later opstel."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Voeg nog een by"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Volgende"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"Die skermslotopsie is gedeaktiveer. Kontak jou organisasie se admin om meer te wete te kom."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Jy kan steeds jou vingerafdruk gebruik om aankope en apptoegang te magtig."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Lig vinger op en raak sensor dan weer"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Kan nie vingerafdruksensor gebruik nie"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Besoek ’n verskaffer wat herstelwerk doen."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Meer sekuriteitinstellings"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Werkprofielslot, enkripsie, en meer"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Enkripsie, eiebewyse, en meer"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"sekuriteit, meer sekuriteitinstellings, meer instellings, gevorderde sekuriteitinstellings"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Meer privaatheidinstellings"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Meer sekuriteit en privaatheid"</string>
    <string name="security_header" msgid="961514795852103424">"Sekuriteit"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Privaatheid"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Werkprofiel"</string>
    <string name="private_space_title" msgid="1752064212078238723">"Privaat ruimte"</string>
    <string name="private_space_summary" msgid="2274405892301976238">"Behou private apps gesluit en versteek"</string>
    <string name="private_space_description" msgid="4059594203775816136">"Hou privaat apps in ’n aparte ruimte wat jy kan versteek of sluit"</string>
    <string name="private_space_lock_title" msgid="7230836881433350526">"Privaat ruimte-slot"</string>
    <string name="private_space_one_lock_summary" msgid="2106513606571219068">"Jy kan jou privaat ruimte ontsluit nes jy jou toestel ontsluit of jy kan ’n ander slot kies"</string>
    <string name="private_space_screen_lock_title" msgid="8679383894967823163">"Gebruik toestelskermslot"</string>
    <string name="private_space_biometric_title" msgid="3934339826674553174">"Gesig- en Vingerafdrukslot"</string>
    <string name="private_space_fingerprint_title" msgid="5989254643211889931">"Vingerafdrukslot"</string>
    <string name="private_space_face_title" msgid="3290402865367663079">"Gesigslot"</string>
    <string name="private_space_biometric_summary" msgid="4403837276018724581">"Tik om op te stel"</string>
    <string name="private_space_fingerprint_unlock_title" msgid="3614016453395789051">"Vingerafdrukslot vir privaat ruimte"</string>
    <string name="private_space_face_unlock_title" msgid="462248384776453613">"Gesigslot vir privaat ruimte"</string>
    <string name="private_space_category_ways_to_unlock" msgid="4356631225316950046">"Maniere om te ontsluit"</string>
    <string name="private_space_screen_lock_summary" msgid="394837965365561070">"Dieselfde as toestelskermslot"</string>
    <string name="private_space_new_lock_title" msgid="9056139964133004094">"Wil jy ’n nuwe slot vir privaat ruimte kies?"</string>
    <string name="private_space_auto_lock_title" msgid="8663409382910601261">"Sluit privaat ruimte outomaties"</string>
    <string name="private_space_auto_lock_page_summary" msgid="8679844515655838654">"Jy kan jou privaat ruimte outomaties sluit as jy jou toestel vir \'n tydperk nie gebruik het nie"</string>
    <string name="private_space_auto_lock_every_time" msgid="1215061855836002830">"Elke keer as die toestel sluit"</string>
    <string name="private_space_auto_lock_after_inactivity" msgid="1748673030841528649">"Ná 5 minute se onaktiwiteit"</string>
    <string name="private_space_auto_lock_never" msgid="595014527119778873">"Nooit"</string>
    <string name="private_space_hide_title" msgid="8687034008994037610">"Versteek as dit gesluit is"</string>
    <string name="privatespace_hide_page_title" msgid="8417507414027827566">"Versteek privaat ruimte as dit gesluit is"</string>
    <string name="privatespace_hide_page_summary" msgid="5525422595477989312">"Jy kan privaat ruimte op jou appslys versteek as jy nie wil hê ander mense moet weet dat jy dit op jou toestel het nie"</string>
    <string name="privatespace_access_header" msgid="6066826215718835041">"Kry toegang tot privaat ruimte wanneer dit versteek is"</string>
    <string name="privatespace_search_description" msgid="3121043205513022357">"Voer in jou appslys “privaat ruimte” op die soekbalk in"</string>
    <string name="privatespace_tap_tile_description" msgid="8346440188590931635">"Tik op die privaat ruimte-teël"</string>
    <string name="privatespace_unlock_description" msgid="3177710543121916413">"Ontsluit jou privaat ruimte"</string>
    <string name="privatespace_hide_off_summary" msgid="7227778747159633671">"Af"</string>
    <string name="privatespace_hide_on_summary" msgid="6136704537527640183">"Aan"</string>
    <string name="private_space_category_system" msgid="1286843321867285700">"Stelsel"</string>
    <string name="private_space_delete_title" msgid="636873505724100006">"Vee privaat ruimte uit"</string>
    <string name="private_space_delete_header" msgid="4594429153176776184">"Wil jy privaat ruimte uitvee?"</string>
    <string name="private_space_delete_summary" msgid="3344372988408565545">"Jou privaat ruimte sal van jou toestel verwyder word. Alle apps en data sal uitgevee word. Jy kan nie hierdie handeling ontdoen nie."</string>
    <string name="private_space_accounts" msgid="1078277762792056395">"Die volgende rekeninge sal uit jou privaat ruimte verwyder word:"</string>
    <string name="private_space_delete_button_label" msgid="1256981385318225002">"Vee uit"</string>
    <string name="private_space_confirm_deletion_header" msgid="3468651585498942977">"Vee tans privaat ruimte uit …"</string>
    <string name="private_space_confirm_deletion_summary" msgid="342544588554284686">"Dit sal ’n paar oomblikke neem"</string>
    <string name="private_space_deleted" msgid="7692240901492540053">"Privaat ruimte is uitgevee"</string>
    <string name="private_space_delete_failed" msgid="7705795653796174741">"Kon nie privaat ruimte uitvee nie"</string>
    <string name="private_space_unlocked" msgid="9091600948712932046">"Privaat ruimte ontsluit"</string>
    <string name="no_device_lock_title" msgid="1078223464721029954">"Stel ’n skermslot"</string>
    <string name="no_device_lock_summary" msgid="7436025227616244687">"Stel ’n skermslot op dié toestel om jou privaat ruimte te gebruik"</string>
    <string name="no_device_lock_action_label" msgid="2640487005629001288">"Stel skermslot"</string>
    <string name="no_device_lock_cancel" msgid="4412602160321228863">"Kanselleer"</string>
    <string name="private_space_cancel_label" msgid="379259667396956886">"Kanselleer"</string>
    <string name="private_space_setup_button_label" msgid="2094882154623560585">"Stel op"</string>
    <string name="private_space_setup_title" msgid="2272968244329821450">"Privaat ruimte"</string>
    <string name="private_space_hide_apps_summary" msgid="4418722947376042418">"Versteek of sluit privaat apps op ’n aparte plek. Gebruik ’n toegewyde Google-rekening vir ekstra sekuriteit."</string>
    <string name="private_space_setup_sub_header" msgid="5454598292017819146">"Stel jou privaat ruimte op"</string>
    <string name="private_space_separate_account_text" msgid="4492251315012955548"><b>"Kies ’n Google-rekening vir jou ruimte"</b>\n"As jy ’n toegewyde rekening gebruik, help dit om te keer dat gesinkroniseerde lêers, foto’s en e-posse buite jou ruimte verskyn"</string>
    <string name="private_space_protected_lock_text" msgid="9123250938334372735"><b>"Stel ’n slot"</b>\n"Sluit jou ruimte om te keer dat ander mense dit oopmaak"</string>
    <string name="private_space_install_apps_text" msgid="5693139160766464498"><b>"Installeer apps"</b>\n"Jou privaat ruimte het sy eie Play Winkel sodat jy apps maklik kan installeer."</string>
    <string name="private_space_apps_permission_text" msgid="7030946025253366172">"Apps in jou privaat ruimte sal nie in toestemmingbestuurder, privaatheidkontroleskerm en ander instellings verskyn wanneer jou privaat ruimte gesluit is nie.\n\nJou privaat ruimte kan nie na ’n nuwe toestel geskuif word nie. Jy sal ’n ander privaat ruimte moet opstel as jy dit op ’n ander toestel wil gebruik.\n\nEnigiemand wat jou toestel aan ’n rekenaar koppel of skadelike apps op jou toestel installeer, sal moontlik toegang tot jou privaat ruimte kan kry."</string>
    <string name="private_space_setting_up_text" msgid="8458035555212009528">"Stel tans privaat ruimte op …"</string>
    <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Kennisgewings van privaat ruimte-apps word versteek as dit gesluit is"</string>
    <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Verken privaatruimte-instellings om privaat ruimte te versteek en outomatiese sluiting op te stel"</string>
    <!-- no translation found for private_space_apps_installed_title (4781838023423527730) -->
    <skip />
    <string name="private_space_error_screen_title" msgid="739381738044418346">"Kon nie privaat ruimte opstel nie"</string>
    <string name="private_space_tryagain_label" msgid="8305362615231738367">"Probeer weer"</string>
    <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Wil jy skermslot gebruik om privaat ruimte te ontsluit?"</string>
    <string name="private_space_lockscreen_summary" msgid="430569465080645805">"Jy kan jou privaat ruimte ontsluit nes jy jou toestel ontsluit of jy kan ’n ander slot kies"</string>
    <string name="private_space_use_screenlock_label" msgid="9182153443192032782">"Gebruik skermslot"</string>
    <string name="private_space_set_lock_label" msgid="1790408277477408475">"Kies nuwe slot"</string>
    <string name="private_space_success_title" msgid="4351904015352046118">"Gereed!"</string>
    <string name="private_space_access_text" msgid="4433988836344567888">"Gaan na jou appslys en rollees af om jou privaat ruimte te kry"</string>
    <string name="private_space_done_label" msgid="1020482651595246071">"Klaar"</string>
    <string name="private_space_scrolldown_to_access" msgid="4820954877349434545">"Rollees af om privaat ruimte te vind"</string>
    <string name="private_space_retry_signin_title" msgid="8090276618867918844">"Meld aan"</string>
    <string name="private_space_retry_summary" msgid="1920444015972648774">"Meld aan by ’n rekening om saam met jou privaat ruimte te gebruik"</string>
    <string name="private_space_skip_login_label" msgid="7078019409056628192">"Nie nou nie"</string>
    <string name="private_space_continue_login_label" msgid="7779965766333065391">"Gaan voort"</string>
    <string name="private_space_lock_setup_title" msgid="6541564212199510787">"Kies ’n slot vir jou privaat ruimte"</string>
    <string name="private_space_lock_setup_description" msgid="423405593476300918">"Jy kan jou privaat ruimte met jou vingerafdruk ontsluit. Om veiligheidsredes vereis hierdie opsie ’n rugsteunslot."</string>
    <string name="private_space_choose_your_pin_header" msgid="4560802934975898265">"Stel \'n PIN vir jou privaat ruimte"</string>
    <string name="private_space_choose_your_password_header" msgid="7660259341095044434">"Stel \'n wagwoord vir jou privaat ruimte"</string>
    <string name="private_space_choose_your_pattern_header" msgid="2165607102459936724">"Stel \'n patroon vir jou privaat ruimte"</string>
    <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Apps en kennisgewings"</string>
    <string name="private_space_notifications_title" msgid="3456249671149740404">"Sensitiewe kennisgewings op sluitskerm"</string>
    <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Wys sensitiewe inhoud wanneer privaat ruimte ontsluit is"</string>
    <!-- no translation found for private_space_gaia_education_title (3787414895669666563) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_description (1592753570023264559) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_header (7835879839637613495) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_bullet1 (641701340908301992) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_bullet2 (3679859681253672976) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_bullet3 (1703614225321289717) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_bullet4 (515761604505366164) -->
    <skip />
    <!-- no translation found for private_space_gaia_education_got_it (7824029819615566806) -->
    <skip />
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Jy kan tot <xliff:g id="COUNT">%d</xliff:g> vingerafdrukke byvoeg"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Jy het die maksimum aantal vingerafdrukke bygevoeg"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Kan nie nog vingerafdrukke byvoeg nie"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Vee \"<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\" uit"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Jy sal nie jou vingerafdruk kan gebruik om jou werkprofiel te ontsluit, aankope te magtig of by werkprogramme aan te meld nie."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Enkripsie"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Geënkripteer"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Stel \'n skermslot"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Stel \'n PIN, patroon of wagwoord vir hierdie toestel vir bykomende sekuriteit."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Stel skermslot"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Stel ’n skermslot"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Stel ’n PIN, patroon of wagwoord vir hierdie toestel vir bykomende sekuriteit."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Beveilig jou foon"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Voeg vingerafdruk by om te ontsluit"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Kies skermslot"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Kies \'n skermslot"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Kies \'n nuwe skermslot"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Kies slot vir werkprogramme"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Kies \'n nuwe werkslot"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Stel \'n rugsteunskermslot vir bykomende sekuriteit"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Kies jou rugsteunmetode vir skermsluiting"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"As jy jou skermslot vergeet, kan jou IT-admin dit nie terugstel nie."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Stel ’n afsonderlike werkslot"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Jy kan jou IT-admin vra om hierdie slot terug te stel as jy dit vergeet"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Skermslotopsies"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Skermslotopsies"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Outobevestig ontsluiting"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Ontsluit outomaties as jy ’n korrekte PIN van 6 of meer syfers invoer. Dit is effens minder veilig as om op Enter te tik om te bevestig."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Outobevestig korrekte PIN"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Dit is veiliger om jou PIN te bevestig deur op Enter te tik as om outobevestiging te gebruik"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Voer toestel-PIN in om outobevestig te aktiveer"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Voer toestel-PIN in om outobevestig te deaktiveer"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Skermslot"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Werkprofielslot"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Geen"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Swiep"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Patroon"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Wagwoord"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Nie nou nie"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Huidige skermslot"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Patroon • Vingerafdruk"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN • Vingerafdruk"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Wagwoord • Vingerafdruk"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Gaan voort sonder vingerafdruk"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Patroon • Gesig"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN • Gesig"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Wagwoord • Gesig"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Gaan voort sonder Gesigslot"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Gaan voort sonder vingerafdruk of gesig"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Geen"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Swiep"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Patroon"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Wagwoord"</string>
    <string name="unlock_disable_frp_warning_title" msgid="2545569051372893686">"Verwyder alle soorte toestelontsluitings"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Verwyder profielbeskerming?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"\'n Patroon beskerm jou foon as dit verlore raak of gesteel word"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"\'n Patroon beskerm jou foon as dit verlore raak of gesteel word.<xliff:g id="EMPTY_LINE">

</xliff:g>Dit vee ook die vingerafdrukmodel uit wat op jou toestel geberg is. Jy sal nie jou vingerafdruk vir stawing in programme kan gebruik nie."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"\'n Patroon beskerm jou foon as dit verlore raak of gesteel word.<xliff:g id="EMPTY_LINE">

</xliff:g>Jou gesigmodel sal ook permanent en veilig uitgevee word. Jy sal nie jou gesig vir stawing in programme kan gebruik nie."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"\'n Patroon beskerm jou foon as dit verlore raak of gesteel word.<xliff:g id="EMPTY_LINE">

</xliff:g>Dit vee ook die vingerafdrukmodel uit wat op jou toestel geberg is. Jou gesigmodel sal ook permanent en veilig uitgevee word. Jy sal nie jou gesig of vingerafdruk vir stawing in programme kan gebruik nie."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"\'n PIN beskerm jou foon as dit verlore raak of gesteel word"</string>
    <string name="unlock_disable_frp_warning_content_pin_authbound_keys" msgid="6497861740382402784">"Jy sal gestoorde data soos jou PIN verloor.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Kaarte wat opgestel is vir kontaklose betaling sal verwyder word.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Beursies en ander apps wat toestelontsluiting benodig sal dalk nie behoorlik werk nie."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"\'n PIN beskerm jou foon as dit verlore raak of gesteel word.<xliff:g id="EMPTY_LINE">

</xliff:g>Dit vee ook die vingerafdrukmodel uit wat op jou toestel geberg is. Jy sal nie jou vingerafdruk vir stawing in programme kan gebruik nie."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_authbound_keys" msgid="8930057076658360799">"Jy sal gestoorde data soos jou PIN en vingerafdrukmodel verloor.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Kaarte wat opgestel is vir kontaklose betaling sal verwyder word.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Beursies en ander apps wat toestelontsluiting benodig sal dalk nie behoorlik werk nie."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"\'n PIN beskerm jou foon as dit verlore raak of gesteel word.<xliff:g id="EMPTY_LINE">

</xliff:g>Jou gesigmodel sal ook permanent en veilig uitgevee word. Jy sal nie jou gesig vir stawing in programme kan gebruik nie."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_authbound_keys" msgid="979399855891561038">"Jy sal gestoorde data soos jou PIN en gesigmodel verloor.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Kaarte wat opgestel is vir kontaklose betaling sal verwyder word.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Beursies en ander apps wat toestelontsluiting benodig sal dalk nie behoorlik werk nie."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"\'n PIN beskerm jou foon as dit verlore raak of gesteel word.<xliff:g id="EMPTY_LINE">

</xliff:g>Dit vee ook die vingerafdrukmodel uit wat op jou toestel geberg is. Jou gesigmodel sal ook permanent en veilig uitgevee word. Jy sal nie jou gesig of vingerafdruk vir stawing in programme kan gebruik nie."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint_authbound_keys" msgid="7019955731206729909">"Jy sal gestoorde data soos jou PIN, gesig- en vingerafdrukmodelle verloor.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Kaarte wat opgestel is vir kontaklose betaling sal verwyder word.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Beursies en ander apps wat toestelontsluiting benodig sal dalk nie behoorlik werk nie."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"\'n Wagwoord beskerm jou foon as dit verlore raak of gesteel word"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"\'n Wagwoord beskerm jou foon as dit verlore raak of gesteel word.<xliff:g id="EMPTY_LINE">

</xliff:g>Dit vee ook die vingerafdrukmodel uit wat op jou toestel geberg is. Jy sal nie jou vingerafdruk vir stawing in programme kan gebruik nie."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"\'n Wagwoord beskerm jou foon as dit verlore raak of gesteel word.<xliff:g id="EMPTY_LINE">

</xliff:g>Jou gesigmodel sal ook permanent en veilig uitgevee word. Jy sal nie jou gesig vir stawing in programme kan gebruik nie."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"\'n Wagwoord beskerm jou foon as dit verlore raak of gesteel word.<xliff:g id="EMPTY_LINE">

</xliff:g>Dit vee die vingerafdrukmodel uit wat op jou toestel geberg is. Jou gesigmodel sal ook permanent en veilig uitgevee word. Jy sal nie jou gesig of vingerafdruk vir stawing in programme kan gebruik nie."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Toestelbeskermingkenmerke sal nie sonder jou skermslot werk nie."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Toestelbeskermingkenmerke sal nie sonder jou skermslot werk nie.<xliff:g id="EMPTY_LINE">

</xliff:g>Dit vee ook die vingerafdrukmodel uit wat op jou toestel geberg is. Jy sal nie jou vingerafdruk vir stawing in programme kan gebruik nie."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Toestelbeskermingkenmerke sal nie sonder jou skermslot werk nie.<xliff:g id="EMPTY_LINE">

</xliff:g>Jou gesigmodel sal ook permanent en veilig uitgevee word. Jy sal nie jou gesig vir stawing in programme kan gebruik nie."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Toestelbeskermingkenmerke sal nie sonder jou skermslot werk nie.<xliff:g id="EMPTY_LINE">

</xliff:g>Dit vee die vingerafdrukmodel uit wat op jou toestel geberg is. Jou gesigmodel sal ook permanent en veilig uitgevee word. Jy sal nie jou gesig of vingerafdruk vir stawing in programme kan gebruik nie."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Vee uit"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> beveel \'n sterk PIN of wagwoord aan en sonder een sal dit dalk nie werk soos verwag nie"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> beveel \'n nuwe PIN of wagwoord aan en sonder een sal dit dalk nie werk soos verwag nie"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> beveel \'n nuwe patroon, PIN of wagwoord aan en sonder een sal dit dalk nie werk soos verwag nie"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> beveel \'n nuwe skermslot aan"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Probeer weer. Poging <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> van <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Jou data sal uitgevee word"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"As jy met jou volgende poging \'n verkeerde patroon invoer, sal hierdie toestel se data uitgevee word"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"As jy met jou volgende poging \'n verkeerde PIN invoer, sal hierdie toestel se data uitgevee word"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"As jy met jou volgende poging \'n verkeerde wagwoord invoer, sal hierdie toestel se data uitgevee word"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"As jy met jou volgende poging \'n verkeerde patroon invoer, sal hierdie gebruiker uitgevee word"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"As jy met jou volgende poging \'n verkeerde PIN invoer, sal hierdie gebruiker uitgevee word"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"As jy met jou volgende poging \'n verkeerde wagwoord invoer, sal hierdie gebruiker uitgevee word"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"As jy met jou volgende poging \'n verkeerde patroon invoer, sal jou werkprofiel en sy data uitgevee word"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"As jy met jou volgende poging \'n verkeerde PIN invoer, sal jou werkprofiel en sy data uitgevee word"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"As jy met jou volgende poging \'n verkeerde wagwoord invoer, sal jou werkprofiel en sy data uitgevee word"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Moet minstens # karakter bevat}other{Moet minstens # karakters wees}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{As jy net syfers gebruik, moet jy minstens 1 syfer gebruik}other{As jy net syfers gebruik, moet jy minstens # syfers gebruik}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{PIN moet minstens # syfer bevat}other{PIN moet minstens # syfers wees}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{PIN moet minstens # syfer bevat, maar ’n PIN met {minAutoConfirmLen} syfers word vir bykomende veiligheid aanbeveel}other{PIN moet minstens # syfers bevat, maar ’n PIN met {minAutoConfirmLen} syfers word vir bykomende veiligheid aanbeveel}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Moet minder as # karakter wees}other{Moet minder as # karakters wees}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Moet minder as # syfer wees}other{Moet minder as # syfers wees}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"Toesteladministrateur laat nie toe dat jy \'n onlangse PIN gebruik nie"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Dit mag nie \'n ongeldige karakter insluit nie"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Moet minstens 1 letter bevat}other{Moet minstens # letters bevat}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Moet minstens 1 kleinletter bevat}other{Moet minstens # kleinletters bevat}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Moet minstens 1 hoofletter bevat}other{Moet minstens # hoofletters bevat}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Moet minstens 1 syfer bevat}other{Moet minstens # syfers bevat}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Moet minstens 1 spesiale simbool bevat}other{Moet minstens # spesiale simbole bevat}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Moet minstens 1 nieletterkarakter bevat}other{Moet minstens # nieletterkarakters bevat}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Moet minstens 1 nienumeriese karakter bevat}other{Moet minstens # nienumeriese karakters bevat}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"Toesteladministrateur laat nie toe dat jy \'n onlangse wagwoord gebruik nie"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Stygende, dalende of herhalende volgorde van syfers word nie toegelaat nie"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Bevestig"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Vee uit"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Skermslot is reeds verander. Probeer weer met die nuwe skermslot."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Kanselleer"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Volgende"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Toesteladministrasie-apps"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Geen aktiewe programme nie"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# aktiewe app}other{# aktiewe apps}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Vertrouensagente"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Stel eers \'n skermslot op om te gebruik"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Geen"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 aktiewe vertrouensagent}other{# aktiewe vertrouensagente}}"</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">"Bind saam met <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="3047893658902159692">"Bevestig om die tweede stuk van jou oudiotoestel by te voeg"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Bluetooth-saambindkode"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Voer die saambindkode in en druk dan Return of Enter"</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"PIN bevat letters of simbole"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Gewoonlik 0000 of 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Moet 16 syfers hê"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Jy sal hierdie PIN dalk op die ander toestel ook moet invoer."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Jy sal hierdie sleutel dalk op die ander toestel ook moet invoer."</string>
    <string name="bluetooth_paring_group_msg" msgid="2455293929036668131">"Bevestig om met die oudiotoestel saam te bind"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Laat toegang tot jou kontakte en oproepgeskiedenis toe"</string>
    <string name="bluetooth_pairing_phonebook_toggle_text" msgid="2474015367387690034">"Gee ook toegang tot kontakte en oproepgeskiedenis"</string>
    <string name="bluetooth_pairing_phonebook_toggle_details" msgid="1367197978487212581">"Inligting sal vir oproepaankondigings en meer gebruik word"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Kon nie aan <xliff:g id="DEVICE_NAME">%1$s</xliff:g> koppel nie."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Beskikbare toestelle"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Koppel"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Ontkoppel"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Bind saam en koppel"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="7326727272747345476">"Wanneer Bluetooth aangeskakel is, kan jou toestel met ander nabygeleë Bluetooth-toestelle kommunikeer"</string>
    <string name="bluetooth_empty_list_bluetooth_off_auto_on_available" msgid="5833847615853525971">"Wanneer Bluetooth aan is, kan jou toestel met ander Bluetooth-toestelle in die omtrek kommunikeer. Kenmerke soos Kitsdeel, Kry My Toestel en toestelligging gebruik Bluetooth."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Wanneer Bluetooth aangeskakel is, kan jou toestel met ander Bluetooth-toestelle in die omtrek kommunikeer.\n\nOm toestelervaring te verbeter, kan apps en dienste steeds enige tyd na toestelle in die omtrek soek, selfs wanneer Bluetooth af is. Dit kan byvoorbeeld gebruik word om ligginggegronde kenmerke en dienste te verbeter. Jy kan dit in Bluetooth-opsporinginstellings verander."</string>
    <string name="bluetooth_scanning_on_info_message_auto_on_available" msgid="5047787966768730069">"Wanneer Bluetooth aan is, kan jou toestel met ander Bluetooth-toestelle in die omtrek kommunikeer. Kenmerke soos Kitsdeel, Kry My Toestel en toestelligging gebruik Bluetooth.\n\nApps en dienste kan steeds enige tyd na toestelle in die omtrek soek, selfs wanneer Bluetooth af is. Dit kan byvoorbeeld gebruik word om ligginggebaseerde kenmerke en dienste te verbeter. Jy kan dit in Bluetooth-skanderinginstellings verander."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Verander"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Toestelbesonderhede"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Sleutelbordinstellings"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Toestel se Bluetooth-adres: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Toestel se Bluetooth-adres:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Vergeet toestel?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Verwyder assosiasie"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Ontkoppel program?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"<xliff:g id="APP_NAME">%1$s</xliff:g>-program sal nie meer aan jou <xliff:g id="DEVICE_NAME">%2$s</xliff:g> koppel nie"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Eksperimenteel. Verbeter oudiogehalte."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Vergeet toestel"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Ontkoppel program"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Maks. gekoppelde Bluetooth-oudiotoestelle"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Kies maksimum aantal gekoppelde Bluetooth-oudiotoestelle"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"NFC-stapelontfoutingloglêer"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Verhoog NFC-stapelloglêervlak"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"NFC- woordryke verkoperontfoutingloglêer"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Sluit bykomende toestelspesifieke verkoperloglêers by foutverslae in, wat privaat inligting kan bevat."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"NFC NCI-loglêer sonder filters"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Vang gedetailleerde NFC-pakkette, wat privaat inligting kan bevat, vas."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Herbegin toestel?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"Gedetailleerde NFC-loglêers is slegs vir ontwikkelingdoeleindes bedoel. Bykomende NFC-data is by foutverslae ingesluit, wat privaat inligting kan bevat. Herbegin jou toestel om hierdie instelling te verander."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Herbegin"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Saai uit"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"weerspieël"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Aktiveer draadlose skermdeling"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Geen nabygeleë toestelle is gekry nie."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Koppel tans"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Gekoppel"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"In gebruik"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Onbeskikbaar"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Draadlose vertoonopsies"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Vergeet"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Klaar"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Naam"</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">"Meld aan"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Maak werf oop"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"<xliff:g id="REMAINING_TIME">%1$s</xliff:g> oor"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Verval op <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> wil Wi-Fi aanskakel"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> wil Wi-Fi afskakel"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Verifieer greepkode van ontfoutbare programme"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Laat ART toe om greepkode vir ontfoutbare programme te verifieer"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Wys herlaaikoers"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Wys die huidige vertoonskermherlaaikoers"</string>
    <string name="show_hdr_sdr_ratio" msgid="4188007289024955585">"Wys HDR/SDR-verhouding"</string>
    <string name="show_hdr_sdr_ratio_summary" msgid="986292785096013733">"Wys die huidige HDR/SDR-verhouding"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Vereis toestelontsluiting vir NFC"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Gereed om programinhoud te stuur via NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Af"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Nie beskikbaar nie want NFC is afgeskakel"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Wanneer hierdie kenmerk aangeskakel is, kan jy programinhoud na \'n ander toestel met NFC-vermoë straal deur die toestelle na aan mekaar te hou. Jy kan byvoorbeeld webbladsye, YouTube-video\'s, kontakte en meer straal.\n\nHou eenvoudig die toestelle bymekaar (gewoonlik rug aan rug) en tik dan op jou skerm. Die program bepaal wat gestraal word."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi-Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Gebruik Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Wi-Fi-instellings"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Kies Wi-Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Skakel tans Wi-Fi aan…"</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Skakel tans Wi-Fi af…"</string>
    <string name="wifi_error" msgid="4903954145386086899">"Fout"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"5 GHz-band is nie in hierdie land beskikbaar nie"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"In vliegtuigmodus"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Stel in kennis oor publieke netwerke"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Stel in kennis wanneer \'n publieke netwerk van hoë gehalte beskikbaar is"</string>
    <string name="wifi_allow_wep_networks" msgid="8772342993235292010">"Laat BEP-netwerke toe"</string>
    <string name="wifi_allow_wep_networks_summary" msgid="3033397893296724615">"BEP is ’n ouer sekuriteitprotokol wat minder veilig is"</string>
    <string name="wifi_allow_wep_networks_summary_carrier_not_allow" msgid="6298103289728210026">"Jou diensverskaffer laat nie BEP-netwerke toe nie omdat hulle minder veilig is"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Skakel Wi-Fi outomaties aan"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Wi‑Fi sal weer aanskakel naby gestoorde netwerke van hoë gehalte, soos jou tuisnetwerk"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Onbeskikbaar omdat ligging afgeskakel is. Skakel "<annotation id="link">"ligging"</annotation>" aan."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Installeer sertifikate"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Om liggingakkuraatheid te verbeter, kan programme en dienste steeds enige tyd na wi‑fi-netwerke soek, selfs wanneer wi‑fi af is. Dit kan byvoorbeeld gebruik word om ligginggegronde kenmerke en dienste te verbeter. Jy kan dit in <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>Wi-fi-opsporinginstellings<xliff:g id="LINK_END_1">LINK_END</xliff:g> verander."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Skakel wi-fi-opsporing aan in <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>Wi‑fi-opsporinginstellings<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Skakel outomaties oor na mobiele data"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Gebruik mobiele data wanneer Wi-Fi geen internettoegang het nie. Datagebruik kan geld."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Voeg netwerk by"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Wi‑Fi-voorkeure"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"Wi‑Fi skakel outomaties weer aan"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"Wi‑Fi skakel nie outomaties weer aan nie"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi-Fi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Skakel Wi-Fi aan om beskikbare netwerke te sien."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Soek tans na netwerke …"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Jy het nie toestemming om die Wi-Fi-netwerk te verander nie."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Skakel Wi‑Fi-opsporing aan?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Om Wi‑Fi outomaties aan te skakel, moet jy eers Wi‑Fi-opsporing aanskakel."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"Wi-fi-opsporing maak dit vir programme en dienste moontlik om enige tyd na Wi-Fi-netwerke te soek, selfs wanneer Wi-Fi af is. Dit kan byvoorbeeld gebruik word om ligginggegronde kenmerke en dienste te verbeter."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Skakel aan"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Wi‑Fi-opsporing is aangeskakel"</string>
    <string name="wifi_settings_warning_wep_network" msgid="2655077013800385646">"Hierdie netwerk gebruik ’n ouer sekuriteitprotokol wat minder veilig is"</string>
    <string name="wifi_settings_wep_networks_blocked_title" msgid="8337700496544833669">"<xliff:g id="NAME">%1$s</xliff:g> is geblokkeer"</string>
    <string name="wifi_settings_wep_networks_summary_toggle_off" msgid="1113138364046142949">"Hierdie netwerk gebruik ’n ouer sekuriteitprotokol genaamd BEP, wat minder veilig is. Jy kan BEP-netwerke toelaat om in elk geval te koppel."</string>
    <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Jou diensverskaffer laat jou nie toe om aan hierdie netwerk te koppel nie, want dit gebruik \'n ouer sekuriteitsprotokol wat minder veilig is"</string>
    <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Laat BEP toe"</string>
    <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Maak toe"</string>
    <!-- no translation found for wifi_settings_wep_networks_disconnect_title (2158070405309246888) -->
    <skip />
    <!-- no translation found for wifi_settings_wep_networks_disconnect_summary (643132352152685538) -->
    <skip />
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Gevorderde opsies"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Gevorderde Opsies-aftreklys"</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"vou uit"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Netwerknaam"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Voer die SSID in"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Sekuriteit"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Versteekte netwerk"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"As jou roeteerder nie \'n netwerk-ID uitsaai nie, maar jy wil in die toekoms daaraan koppel, kan jy die netwerk as versteek stel.\n\nDit kan \'n sekuriteitrisiko skep omdat jou foon gereeld sy sein sal uitsaai om die netwerk te soek.\n\nAs jy die netwerk op versteek stel, sal dit nie jou roeteerderinstellings verander nie."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Seinsterkte"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Status"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Oordragskakelspoed"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Ontvangskakelspoed"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Koppelspoed"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frekwensie"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"IP-adres"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Gestoor via"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"<xliff:g id="NAME">%1$s</xliff:g>-eiebewyse"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"EAP-metode"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Fase 2-stawing"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"CA-sertifikaat"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Minimum TLS-weergawe"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Status van aanlyn sertifikaat"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domein"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Gebruikersertifikaat"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identiteit"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Anonieme identiteit"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Wagwoord"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Wys wagwoord"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"2,4 GHz-band"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"5,0 GHz-band verkies"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"IP-instellings"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privaatheid"</string>
    <string name="wifi_privacy_mac_settings" msgid="3188060664478313363">"MAC"</string>
    <string name="wifi_privacy_device_name_settings" msgid="3699130177041345275">"Toestelnaam"</string>
    <string name="wifi_privacy_send_device_name_toggle_title" msgid="1228107313152880073">"Stuur toestelnaam"</string>
    <string name="wifi_privacy_send_device_name_toggle_summary" msgid="5995365836332817655">"Deel hierdie toestel se naam met die netwerk"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Intekening"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Bekyk of verander intekening"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Ewekansige MAC"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Voeg \'n toestel by"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Sentreer die QR-kode hieronder om die toestel by “<xliff:g id="SSID">%1$s</xliff:g>” te voeg"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Skandeer QR-kode"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Sentreer die QR-kode hieronder om aan “<xliff:g id="SSID">%1$s</xliff:g>” te koppel"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Skandeer \'n QR-kode om by Wi-Fi aan te sluit"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Deel Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Skandeer hierdie QR-kode met \'n ander toestel om by “<xliff:g id="SSID">%1$s</xliff:g>” aan te sluit"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Skandeer hierdie QR-kode om aan “<xliff:g id="SSID">%1$s</xliff:g>” te koppel"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Probeer weer. Kontak die toestelvervaardiger as die kwessie voortduur"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Iets is fout"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Maak seker dat die toestel ingeprop is, gelaai is, en aangeskakel is"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Maak seker dat die toestel ingeprop is, gelaai is, en aangeskakel is. Kontak die toestelvervaardiger as die kwessie voortduur"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Hierdie toestel steun nie byvoeging van “<xliff:g id="SSID">%1$s</xliff:g>” nie"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Probeer om die toestel nader aan jou Wi-Fi-toegangspunt / -roeteerder te skuif"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Gaan die wagwoord na en probeer weer"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Kontak die toestelvervaardiger"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Gaan verbinding na en probeer weer"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Kies netwerk"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Kies \'n netwerk om jou toestel te koppel"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Voeg hierdie toestel by “<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi is met toestel gedeel"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Voeg nog \'n toestel by"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Kies \'n ander netwerk"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Kon nie toestel byvoeg nie"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Toestel gekry"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Deel tans Wi‑Fi met hierdie toestel …"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Koppel tans …"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Deel warmkol"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="5246641326066972419">"Verifieer dat dit jy is"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Wi-Fi-wagwoord: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Warmkolwagwoord: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Outokoppel"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Laat aansluiting aan hierdie netwerk toe wanneer dit binne bereik is"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Voeg toestel by"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Gebruik \'n QR-kode om \'n toestel by hierdie netwerk te voeg"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"QR-kode is nie \'n geldige formaat nie"</string>
    <string name="retry" msgid="7542103800274026915">"Herprobeer"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Deel met ander toestelgebruikers"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(onveranderd)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Kies asseblief"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Veelvuldige sertifikate is bygevoeg)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Gebruik stelselsertifikate"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Moenie verskaf nie"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Vertrou met eerste gebruik"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"Netwerknaam is te lank."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Moet \'n domein spesifiseer."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Sertifikaat word vereis."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Om liggingsakkuraatheid te verbeter en vir ander doele, wil <xliff:g id="APP_NAME">%1$s</xliff:g> netwerkskandering aanskakel, selfs wanneer Wi-Fi af is.\n\n Laat dit toe vir alle programme wat wil skandeer?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"\'n Onbekende program wil netwerkskandering aanskakel om liggingakkuraatheid te verbeter en vir ander doeleindes, selfs wanneer Wi‑Fi af is.\n\nLaat dit toe vir alle programme wat wil skandeer?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Laat toe"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Weier"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Hierdie netwerk het nie internettoegang nie. Bly gekoppel?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Sekere programme en dienste kan weens beperkte konnektiwiteit dalk nie werk nie. Gebruik in elk geval?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Moenie weer vir hierdie netwerk vra nie"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"Wi‑Fi is nie aan die internet gekoppel nie"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Jy kan na die mobiele netwerk oorskakel wanneer Wi-Fi \'n swak verbinding het. Datagebruikheffings kan geld."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Skakel oor na mobiel"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Bly op Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Moet nooit weer wys nie"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Koppel"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Gekoppel aan <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Koppel tans …"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Netwerkverbinding het misluk"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Netwerk nie binne sendbereik nie"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Vergeet"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Wysig"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Stoor"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Netwerkstoring het misluk"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Kanselleer"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Vergeet netwerk?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 netwerk}other{# netwerke}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 intekening}other{# intekeninge}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 netwerk en intekening}other{# netwerke en intekeninge}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Toestel se MAC-adres"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Ewekansige MAC-adres"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Ewekansige MAC-adres (laas gebruik)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Netwerkbesonderhede"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Subnetmasker"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Tipe"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"IPv6-adresse"</string>
    <string name="hotspot_device_details_category" msgid="3110651914598697220">"Besonderhede van warmkoltoestel"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Internetbron"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"Wi‑fi"</string>
    <string name="internet_source_mobile_data" msgid="877403889449201789">"Mobiele data"</string>
    <string name="internet_source_ethernet" msgid="8338472576454100966">"Ethernet"</string>
    <string name="hotspot_battery_charging_summary" msgid="6690892148553288457">"<xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> – Laai tans"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Warmkolverbinding"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Verbindingsterkte"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Gestoorde netwerke"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Intekeninge"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Ander netwerke"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Voer \'n geldige IP-adres in."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Voer \'n geldige deurgangadres in."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Voer \'n geldige DNS-adres in."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Voer \'n netwerkvoorvoegsel in met lengte tussen 0 en 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (tensy deur private DNS geïgnoreer)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (tensy deur private DNS geïgnoreer)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Deurgang"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Lengte van netwerkvoorvoegsel"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Soek vir toestelle"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Soek tans …"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Hernoem toestel"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Portuurtoestelle"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Onthoude groepe"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Kon nie koppel nie."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Kon nie toestel hernoem nie."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Ontkoppel?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"As jy ontkoppel, sal jou verbinding met <xliff:g id="PEER_NAME">%1$s</xliff:g> ophou."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"As jy ontkoppel, sal jou verbinding met <xliff:g id="PEER_NAME">%1$s</xliff:g> en <xliff:g id="PEER_COUNT">%2$s</xliff:g> ander toestelle ophou."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Kanselleer uitnodiging?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Wil jy die uitnodiging kanselleer om met <xliff:g id="PEER_NAME">%1$s</xliff:g> te koppel?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Vergeet hierdie groep?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Wi‑Fi-warmkol"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Deel nie tans internet of inhoud met ander toestelle nie"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Geen wagwoord is gestel nie"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Warmkolnaam"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Warmkolwagwoord"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Skakel warmkol outomaties af"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Wanneer geen toestelle gekoppel is nie"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Brei versoenbaarheid uit"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Help ander toestelle om hierdie warmkol te kry. Verminder warmkol se verbindingspoed."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Help ander toestelle om hierdie warmkol te kry. Verhoog batterygebruik."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Spoed en versoenbaarheid"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2.4 GHz / Met die meeste toestelle versoenbaar"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz / Met baie toestelle versoenbaar"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz / Met min toestelle versoenbaar"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2.4 en 5 GHz / Met die meeste toestelle versoenbaar"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Kies ’n frekwensie vir jou warmkol. Die frekwensie beïnvloed die verbindingspoed en watter soorte toestelle jou warmkol kan kry."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Voorkeurfrekwensie"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Stadiger spoed. Met die meeste toestelle versoenbaar."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Vinnige spoed. Met baie toestelle versoenbaar."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 en 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Vinnige spoed. Hierdie dubbelbandwarmkol is met die meeste toestelle versoenbaar."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Vinnigste spoed. Met min toestelle versoenbaar."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Nie in jou land of streek beskikbaar nie"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"As jou voorkeurfrekwensie nie beskikbaar is nie, kan jou warmkol ’n ander een gebruik. Warmkolsekuriteitinstellings kan verander as jy die frekwensie verander."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Nie met 6 GHz beskikbaar nie"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"Sekuriteitinstellings kan verander as jy die warmkol se frekwensie verander"</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"Kitswarmkol"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"Aan"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Af"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Skakel tans Wi-Fi-warmkol aan..."</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Skakel tans Wi-Fi-warmkol af..."</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Verbinding is nie beskikbaar nie"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Kontak jou diensverskaffer vir besonderhede"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> is aktief"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"AndroidHotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Stoor hierdie netwerk?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Stoor tans …"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Gestoor"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Kan nie stoor nie. Probeer weer."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Stoor netwerke?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Stoor tans <xliff:g id="NUMBER">%d</xliff:g> netwerke …"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Netwerke gestoor"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Wi-Fi-oproepe"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Brei oproepe uit met Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Skakel Wi‑Fi-oproepe aan om dekking te vergroot"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Oproepvoorkeur"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Oproepvoorkeur"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Swerfvoorkeur"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Swerfvoorkeur"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Mobiel"</item>
    <item msgid="3027927219952052398">"Net Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi-Fi"</item>
    <item msgid="7566603075659706590">"Mobiel"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"As Wi-Fi onbeskikbaar is, moet jy mobiele netwerk gebruik"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"As mobiele netwerk onbeskikbaar is, gebruik Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Bel oor Wi-Fi. Die oproep sal eindig as jy nie meer Wi-Fi het nie."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"As Wi-Fi-oproepe aan is, kan jou foon oproepe deur Wi-Fi-netwerke of jou diensverskaffer se netwerk roeteer, afhangend van jou voorkeur en watter sein die sterkste is. Vind by jou diensverskaffer oor tariewe en ander besonderhede uit voordat jy hierdie kenmerk aanskakel.<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">"Noodadres"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Word as jou ligging gebruik wanneer jy \'n noodoproep oor Wi-Fi maak"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Kom meer te wete"</annotation>" oor Private DNS-kenmerke"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Aan"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Aktiveer Wi-Fi-oproepe"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Skakel Wi-Fi-oproepe aan"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Is ontkoppel van <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Klank en vibrasie"</string>
    <string name="account_settings" msgid="255404935489127404">"Rekeninge"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Werkprofielrekeninge – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Persoonlikeprofielrekeninge"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Kloon profielrekeninge"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Werkrekening – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Persoonlike rekening – <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Soek"</string>
    <string name="display_settings" msgid="7197750639709493852">"Skerm"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Outodraai skerm"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Af"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Aan"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Aan – gesiggegrond"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Gesigbespeuring"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Kom meer te wete oor outodraai"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Skermresolusie"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Hoë resolusie"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Volle resolusie"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"Volle resolusie gebruik meer van jou battery. As jy jou resolusie oorskakel, sal sommige programme dalk herbegin."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Gekies"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Kleure"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Natuurlik"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Gemaksimeer"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Intens"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Aanpasbaar"</string>
    <string name="brightness" msgid="6216871641021779698">"Helderheidsvlak"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Aanpasbare helderheid"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"Jou skermhelderheid sal outomaties by jou omgewing en aktiwiteite aanpas. Jy kan die glyer self skuif om aanpasbare helderheid te help om te leer wat jy verkies."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Aan"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Af"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Wys witbalans"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="fold_lock_behavior_title" msgid="786228803694268449">"Hou aan om apps te gebruik wanneer gevou"</string>
    <string name="disable_game_default_frame_rate_title" msgid="3712908601744143753">"Deaktiveer verstekraamtempo vir speletjies"</string>
    <string name="disable_game_default_frame_rate_summary" msgid="4436762704707434225">"Deaktiveer die beperking van die maksimum raamtempo vir speletjies teen <xliff:g id="FRAME_RATE">%1$d</xliff:g> Hz."</string>
    <string name="peak_refresh_rate_title" msgid="2056355754210341011">"Gladde vertoning"</string>
    <string name="peak_refresh_rate_summary" msgid="3212309985294885790">"Verhoog die herlaaitempo vir sommige inhoud outomaties na <xliff:g id="ID_1">%1$d</xliff:g> Hz. Verhoog batterygebruik."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Dwing na hoogste herlaaikoers"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Hoogste herlaaikoers vir verbeterde raaksensitiwiteit en animasiegehalte. Verhoog batterygebruik."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Skermaandag"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Kameratoegang is nodig"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Kameratoegang word vereis vir skermaandag. Tik om toestemmings vir Toestelpersonaliseringdienste te bestuur"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Bestuur toestemmings"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Keer dat jou skerm afskakel terwyl jy daarna kyk"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Skermaandag gebruik die voorste kamera om te sien of iemand na die skerm kyk. Dit werk op die toestel, en prente word nooit geberg of na Google toe gestuur nie."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Skakel skermaandag aan"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Hou skerm aan terwyl jy daarna kyk"</string>
    <string name="power_consumption_footer_summary" msgid="4901490700555257237">"Langer skermuitteltyd sal meer battery gebruik."</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"Kamera is gesluit"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Kamera moet ontsluit wees vir gesigbespeuring"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"Kamera moet ontsluit word vir skermaandag"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Kameratoegang word vereis vir gesigbespeuring. Tik om toestemmings vir Toestelpersonaliseringdienste te bestuur"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Bestuur toestemmings"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Aandbeligting"</string>
    <string name="night_display_text" msgid="4789324042428095383">"Aandbeligting tint jou skerm geelbruin. Dit maak dit makliker om in dowwe lig te lees of na jou skerm te kyk en sal jou dalk help om makliker aan die slaap te raak."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Skedule"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Geen"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Skakel aan op gepasmaakte tyd"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Skakel aan van sononder tot sonop"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Begintyd"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Eindtyd"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensiteit"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Sal nooit outomaties aanskakel nie"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Sal outomaties aanskakel om <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Sal outomaties aanskakel met sonsondergang"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Sal nooit outomaties afskakel nie"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Sal outomaties afskakel om <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Sal outomaties afskakel met sonsopkoms"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Aandbeligting is nie tans aan nie"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Toestelligging is nodig om jou sonsondergang- en -opkomstye te bepaal."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Ligginginstellings"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Skakel nou aan"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Skakel nou af"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Skakel aan tot sonsopkoms"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Skakel af tot sonsondergang"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Donkermodus"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Skedule"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Geen"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Skakel aan van sononder tot sonop"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Skakel aan op gepasmaakte tyd"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Skakel met slaaptyd aan"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Status"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Sal nooit outomaties aanskakel nie"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Sal outomaties aanskakel met sonsondergang"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Sal outomaties aanskakel om <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Sal outomaties aanskakel met slaaptyd"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Sal nooit outomaties afskakel nie"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Sal outomaties afskakel met sonsopkoms"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Sal outomaties afskakel om <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Sal outomaties afskakel ná slaaptyd"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"Donkertema gebruik op sommige skerms \'n swart agtergrond om te help om die battery langer te laat hou. Donkertemaskedules wag totdat jou skerm af is voordat hulle aanskakel."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"Donkertema volgs tans jou Slaaptydmodus-skedule"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Slaaptydmodus-instellings"</string>
    <string name="even_dimmer_display_title" msgid="8589063452814896327">"Selfs dowwer"</string>
    <string name="even_dimmer_display_summary" msgid="120301078873242172">"Laat toestel toe om dowwer as gewoonlik te word"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Skermuitteltyd"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Na <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> se onaktiwiteit"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Nie gestel nie"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Muurpapier"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Muurpapier en styl"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Tuisskerm, sluitskerm"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Verander muurpapier"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Personaliseer jou skerm"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Kies muurpapier uit"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Pasmaak jou foon"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Probeer verskillende style, muurpapiere, en meer"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Sluimerskerm"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"sluimerskerm"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Nie beskikbaar nie omdat slaaptydmodus aan is"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Gebruik sluimerskerm"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Terwyl dit laai of gedok is"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Terwyl dit gedok is en laai"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Terwyl dit laai"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Terwyl dit gedok is"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nooit"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Aan/<xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Af"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Wanneer om te begin"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Lig op om wakker te maak"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Stemmingvertoning"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Wanneer om te wys"</string>
    <string name="doze_title" msgid="1523090408230862316">"Maak skerm wakker vir kennisgewings"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Wanneer die skerm donker is, sal dit aanskakel vir nuwe kennisgewings"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Wys altyd tyd en inligting"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Verhoogde batterygebruik"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Teks in vetdruk"</string>
    <string name="title_font_size" msgid="570613010306330622">"Lettertipegrootte"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Maak teks groter of kleiner"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"SIM-slotinstellings"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"SIM-slot"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Sluit SIM"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Verander SIM-PIN"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"SIM PIN"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Sluit SIM"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Ontsluit SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"Ou SIM PIN"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Nuwe SIM PIN"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Voer nuwe PIN weer in"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"SIM PIN"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Tik ’n PIN van 4 tot 8 syfers in"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"PIN\'e stem nie ooreen nie"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"SIM-PIN is suksesvol verander"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Kan nie PIN deaktiveer nie."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Kan nie PIN aktiveer nie."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"OK"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Kanselleer"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Gebruik <xliff:g id="CARRIER">%1$s</xliff:g> vir mobiele data?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Jy gebruik tans <xliff:g id="CARRIER2_0">%2$s</xliff:g> vir mobiele data. As jy na <xliff:g id="CARRIER1">%1$s</xliff:g> oorskakel, sal <xliff:g id="CARRIER2_1">%2$s</xliff:g> nie meer vir mobiele data gebruik word nie."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Gebruik <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"Dateer voorkeur-SIM op?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> is die enigste SIM in jou toestel. Wil jy hierdie SIM vir mobiele data, oproepe en SMS\'e gebruik?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Verbeter mobieldatadekking?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Laat jou toestel toe om outomaties oor te skakel na <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> vir mobiele data wanneer dit meer beskikbaar is."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Jou organisasie kan dalk oproepe, boodskappe en netwerkverkeer sien."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Verkeerde SIM PIN-kode, jy sal nou jou diensverskaffer moet kontak om jou toestel te ontsluit."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Verkeerde PIN-kode vir SIM. Jy het # poging oor voordat jy jou diensverskaffer moet kontak om jou toestel te ontsluit.}other{Verkeerde PIN-kode vir SIM. Jy het # pogings oor.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Verkeerde SIM-PIN-kode. Jy het 1 oorblywende poging voordat jy jou diensverskaffer sal moet kontak om jou toestel te ontsluit."</string>
    <string name="pin_failed" msgid="3726505565797352255">"SIM PIN-bewerking het misluk!"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Stelselopdaterings"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Android-weergawe"</string>
    <string name="security_patch" msgid="4071756145347865382">"Android-sekuriteitopdatering"</string>
    <string name="model_info" msgid="8997566254717810904">"Model"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Hardewareweergawe"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Jaar van vervaardiging"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"Toerusting-ID"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Basisbandweergawe"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Kernweergawe"</string>
    <string name="build_number" msgid="9009733242117579826">"Bounommer"</string>
    <string name="module_version" msgid="1787518340082046658">"Google Play-stelselopdatering"</string>
    <string name="battery_info" msgid="7873528123969546728">"Batteryinligting"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Nie beskikbaar nie"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Berging"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Berging en kas"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Bergingsinstellings"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (SIM-gleuf <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (SIM-gleuf <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (SIM-gleuf <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (primêr)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Kies gestoorde netwerk om te bekyk"</string>
    <string name="status_imei" msgid="5719752369250485007">"IMEI"</string>
    <string name="status_imei_sv" msgid="6908985558726440951">"IMEI SV"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"PRL-weergawe"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (SIM-gleuf <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (SIM-gleuf <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (primêr)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Aan"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Af"</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">"Soort mobieledatanetwerk"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Soort mobielestemnetwerk"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Operateurinligting"</string>
    <string name="status_data_state" msgid="525196229491743487">"Mobielenetwerk-status"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Diensstatus"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Seinsterkte"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Swerwing"</string>
    <string name="status_operator" msgid="4335640583552058491">"Netwerk"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Wi-Fi-MAC-adres"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Toestel se Wi‑Fi-MAC-adres"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Bluetooth-adres"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Reeksnommer"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Tyd aanlyn"</string>
    <string name="battery_manufacture_date" msgid="7139426520156833987">"Vervaardigingdatum"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Datum van eerste gebruik"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Siklustelling"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Onbeskikbaar"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Bereken tans…"</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Hernoem"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Monteer"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Demonteer"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formateer SD-kaart vir draagbare berging"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formateer kaart"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formateer as draagbaar"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formateer "</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Skuif data"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Vergeet"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Stel op"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Maak spasie beskikbaar"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Bestuur berging"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Maak spasie beskikbaar"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Gaan na die Files-program om spasie te bestuur en beskikbaar te maak"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Ander gebruikers"</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> is gemonteer"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Kon <xliff:g id="NAME">%1$s</xliff:g> nie monteer nie"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> is veilig gedemonteer"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Kon <xliff:g id="NAME">%1$s</xliff:g> nie veilig demonteer nie"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Hernoem berging"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Hierdie <xliff:g id="NAME_0">^1</xliff:g> is gekorrupteer. \n\nOm hierdie <xliff:g id="NAME_1">^1</xliff:g> te gebruik, moet jy dit eers opstel."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Jy kan hierdie SD-kaart formateer om foto\'s, video\'s, musiek en meer te berg en op ander toestelle toegang daartoe te kry. \n\n"<b>"Alle data op hierdie SD-kaart sal uitgevee word."</b>" \n\n"<b>"Voordat jy formateer"</b>" \n\n"<b>"Rugsteun foto\'s en ander media"</b>" \nSkuif jou medialêers na ander berging op hierdie toestel of gebruik ’n USB-kabel om dit na ’n rekenaar toe oor te dra. \n\n"<b>"Rugsteun programme"</b>" \nAlle programme wat op hierdie <xliff:g id="NAME">^1</xliff:g> geberg is, sal gedeïnstalleer word en hul data sal uitgevee word. Skuif hierdie programme na alternatiewe berging op hierdie toestel as jy hulle wil behou."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"As jy hierdie <xliff:g id="NAME_0">^1</xliff:g> uithaal, sal programme daarop ophou werk, en medialêers wat daarop geberg is, sal nie beskikbaar wees voordat dit weer ingesit word nie."</b>" \n\nHierdie <xliff:g id="NAME_1">^1</xliff:g> is geformateer om net in hierdie toestel te werk. Dit sal nie in enige ander toestelle werk nie."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Sit hierdie <xliff:g id="NAME">^1</xliff:g> weer in om die programme, foto\'s of data te gebruik wat dit bevat. \n\nAndersins kan jy kies om hierdie berging te vergeet as die toestel nie beskikbaar is nie. \n\nAs jy kies om te vergeet, sal al die data wat die toestel bevat, vir altyd verlore wees. \n\nJy kan die programme later herinstalleer, maar die data wat in hierdie toestel geberg is, sal verlore wees."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Vergeet <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Al die programme, foto\'s en data wat op hierdie <xliff:g id="NAME">^1</xliff:g> geberg is, sal vir altyd verlore wees."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"Stelsel sluit lêers in wat gebruik word om Android-weergawe <xliff:g id="VERSION">%s</xliff:g> te laat loop"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Gasmodusgebruikers kan nie SD-kaarte formateer nie"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formateer tans <xliff:g id="NAME">^1</xliff:g> …"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Moenie die <xliff:g id="NAME">^1</xliff:g> verwyder terwyl dit geformateer word nie."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"<xliff:g id="NAME">^1</xliff:g> is geformateer"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Skuif <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Dit sal \'n kort rukkie vat om <xliff:g id="APP">^1</xliff:g> en sy data na <xliff:g id="NAME_0">^2</xliff:g> te skuif. Jy sal nie die program kan gebruik voordat dit klaar geskuif is nie. \n\nMoenie die <xliff:g id="NAME_1">^2</xliff:g> verwyder terwyl daar geskuif word nie."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Jy moet gebruiker <xliff:g id="APP">^1</xliff:g> ontsluit om data te skuif."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Skuif tans <xliff:g id="APP">^1</xliff:g> …"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Moenie die <xliff:g id="NAME">^1</xliff:g> verwyder terwyl daar geskuif word nie. \n\nDie <xliff:g id="APP">^2</xliff:g>-program in hierdie toestel sal nie beskikbaar wees voordat dit klaar geskuif is nie."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Hoe sal jy hierdie <xliff:g id="NAME">^1</xliff:g> gebruik?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Of"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Formateer SD-kaart vir draagbare berging"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Berg foto\'s, video\'s, musiek en meer, en kry toegang daartoe van ander toestelle af. &lt;a href=https://support.google.com/android/answer/12153449&gt;Kom meer te wete oor hoe om ’n SD-kaart op te stel&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formateer"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Stel later op"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Formateer hierdie <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Hierdie <xliff:g id="NAME_0">^1</xliff:g> moet geformateer word om programme, lêers en media te stoor. \n\nFormatering sal bestaande inhoud op die <xliff:g id="NAME_1">^2</xliff:g> uitvee. Om te keer dat jy inhoud verloor, rugsteun dit op \'n ander <xliff:g id="NAME_2">^3</xliff:g> of toestel."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Hierdie <xliff:g id="NAME_0">^1</xliff:g> moet geformateer word om foto\'s, video\'s, musiek en meer te berg. \n\nFormatering sal bestaande inhoud op die <xliff:g id="NAME_1">^2</xliff:g> uitvee. Rugsteun inhoud op ’n ander <xliff:g id="NAME_2">^3</xliff:g> of toestel om te keer dat jy dit verloor."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formateer <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Skuif inhoud na <xliff:g id="NAME">^1</xliff:g> toe?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Tydens die skuif:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"Moenie die <xliff:g id="NAME">^1</xliff:g> verwyder nie"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Sommige programme sal nie werk nie"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Skuif inhoud"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Skuif inhoud later"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Skuif tans inhoud …"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"Stadig <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Jy kan steeds hierdie <xliff:g id="NAME_0">^1</xliff:g> gebruik, maar dit kan stadig wees. \n\nProgramme wat op hierdie <xliff:g id="NAME_1">^2</xliff:g> geberg is, sal dalk nie behoorlik werk nie en dit kan lank neem om inhoud oor te dra. \n\nProbeer \'n vinniger <xliff:g id="NAME_2">^3</xliff:g> gebruik of gebruik eerder hierdie <xliff:g id="NAME_3">^4</xliff:g> as draagbare berging."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Begin oor"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Gaan voort"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Jy kan begin om jou <xliff:g id="NAME">^1</xliff:g> te gebruik"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Jy kan begin om jou <xliff:g id="NAME">^1</xliff:g> te gebruik"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Jy kan begin om jou <xliff:g id="NAME">^1</xliff:g> te gebruik"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Batterystatus"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Batteryvlak"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Gemeenskaplik"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Gemeenskaplike instellings"</string>
    <string name="satellite_setting" msgid="706846910912477125">"Satellietboodskappe"</string>
    <string name="apn_settings" msgid="4295467389400441299">"Toegangspuntname"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Redigeer toegangspunt"</string>
    <string name="apn_add" msgid="9069613192201630934">"Voeg toegangspunt by"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Nie gestel nie"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Nie gestel nie"</string>
    <string name="apn_name" msgid="6677695784108157953">"Naam"</string>
    <string name="apn_apn" msgid="5812828833797458602">"Toegangspuntnaam"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Instaanbediener"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Poort"</string>
    <string name="apn_user" msgid="5831763936428279228">"Gebruikernaam"</string>
    <string name="apn_password" msgid="7435086635953953029">"Wagwoord"</string>
    <string name="apn_server" msgid="6997704279138388384">"Bediener"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"MMS-instaanbediener"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"MMS-poort"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Stawingstipe"</string>
    <string name="apn_type" msgid="1835573305077788773">"Toegangspunt-tipe"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Toegangspunt-protokol"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"APN-swerwingsprotokol"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"APN aktiveer/deaktiveer"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN is geaktiveer"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN gedeaktiveer"</string>
    <string name="bearer" msgid="3231443241639159358">"Draer"</string>
    <string name="network_type" msgid="748590707422733595">"Netwerktipe"</string>
    <string name="network_type_unspecified" msgid="7756349656194518725">"Ongespesifiseer"</string>
    <string name="mvno_type" msgid="4734654257494971247">"MVNO-tipe"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"MVNO-waarde"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Vee toegangspunt uit"</string>
    <string name="menu_new" msgid="6571230342655509006">"Nuwe toegangspunt"</string>
    <string name="menu_save" msgid="6611465355127483100">"Stoor"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Kanselleer"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_duplicate_apn_entry" msgid="7792928408935276618">"Duplikaat-apn-inskrywing."</string>
    <string name="error_name_empty" msgid="1258275899283079142">"Die naamveld kan nie leeg wees nie."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"Die APN kan nie leeg wees nie."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"MCC-veld moet 3 syfers wees."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"Die MNC-veld moet uit 2 of 3 syfers bestaan."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"Diensverskaffer laat nie toe dat APN\'e van tipe %s bygevoeg word nie."</string>
    <string name="error_mmsc_valid" msgid="8380951905485647380">"MMSC-veld moet geldig wees."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Laai verstek APN-instellings terug"</string>
    <string name="menu_restore" msgid="4310539620115151551">"Stel terug na verstek"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Terugstel van verstek APN-instellings voltooi"</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Stel opsies terug"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Stel selnetwerkinstellings terug"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Dit sal alle selnetwerkinstellings terugstel"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Stel selnetwerkinstellings terug?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Stel Bluetooth en wi‑fi terug"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Dit sal alle wi‑fi- en Bluetooth-instellings terugstel. Jy kan nie hierdie handeling ontdoen nie."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Stel terug"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Bluetooth en wi‑fi is teruggestel"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Vee e-SIM-kaarte uit"</string>
    <string name="reset_esim_desc" msgid="6125192435907740751">"Dit sal nie jou mobieldiensplan kanselleer nie. Kontak jou diensverskaffer om ’n vervanging-SIM te kry."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Stel instellings terug"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Stel alle netwerkinstellings terug? Jy kan nie hierdie handeling ontdoen nie."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Stel alle netwerkinstellings terug en vee e-SIM-kaarte uit? Jy kan nie hierdie handeling ontdoen nie."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Stel instellings terug"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Stel terug?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"Netwerkterugstelling is nie vir hierdie gebruiker beskikbaar nie"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Netwerkinstellings is teruggestel"</string>
    <string name="reset_esim_error_title" msgid="6516110227665862295">"Kan nie e-SIM’s uitvee nie"</string>
    <string name="reset_esim_error_msg" msgid="8459527827897797168">"Iets het skeefgeloop en jou e-SIM’s is nie uitgevee nie.\n\nHerbegin jou toestel en probeer weer."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Vee alle data uit (fabriekterugstelling)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Vee alle data uit (fabriekterugstelling)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Musiek"</li>\n<li>"Foto\'s"</li>\n<li>"Ander gebruikerdata"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"e-SIM-kaarte"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Dit sal nie jou mobiele diensplan kanselleer nie."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Al jou persoonlike inligting en afgelaaide programme sal uitgevee word. Jy kan nie hierdie handeling ontdoen nie."</string>
    <string name="main_clear_final_desc_esim" msgid="6592404057237813989">"Al jou persoonlike inligting, insluitend afgelaaide apps en e-SIM’s, sal uitgevee word. Jy kan nie hierdie handeling ontdoen nie."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Vee alle data uit?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"Fabriekterugstelling is nie vir hierdie gebruiker beskikbaar nie"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Vee tans uit"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Wag asseblief …"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Oproepinstellings"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Stel stemboodskapdiens, oproepaanstuur, oproep wag, beller-ID op"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"USB-verbinding"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Wi-Fi-warmkol"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Bluetooth-verbinding"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Verbinding"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Warmkol en verbinding"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Warmkol is aan, verbind"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Warmkol is aan"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Verbinding"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Kan nie verbind of Wi-Fi-warmkol gebruik wanneer Databespaarder aan is nie"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Net warmkol"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Net USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Net Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Net Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Warmkol, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Warmkol, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Warmkol, 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">"Warmkol, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Warmkol, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Warmkol, 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">"Warmkol, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Deel nie tans internet met ander toestelle nie"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Af"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"USB-verbinding"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Bluetooth-verbinding"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Ethernet-verbinding"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Gebruik warmkol en verbinding om deur jou mobiele dataverbinding internet aan ander toestelle te verskaf. Programme kan ook \'n warmkol skep om inhoud met nabygeleë toestelle te deel."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Gebruik warmkol en verbinding om deur jou Wi-Fi- of mobiele dataverbinding internet aan ander toestelle te verskaf. Programme kan ook \'n warmkol skep om inhoud met toestelle in die omtrek te deel."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Hulp"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Mobiele netwerk"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"SMS-program"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Verander SMS-program?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Gebruik <xliff:g id="NEW_APP">%1$s</xliff:g> in plaas van <xliff:g id="CURRENT_APP">%2$s</xliff:g> as jou SMS-program?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Gebruik <xliff:g id="NEW_APP">%s</xliff:g> as jou SMS-program?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Verander Wi-Fi-assistent?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Gebruik <xliff:g id="NEW_APP">%1$s</xliff:g> in plaas van <xliff:g id="CURRENT_APP">%2$s</xliff:g> om jou netwerkverbindings te bestuur?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Gebruik <xliff:g id="NEW_APP">%s</xliff:g> om jou netwerkverbindings te bestuur?"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Onlangse liggingversoeke"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Ligging vir werkprofiel"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Programliggingtoestemmings"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Ligging is af"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# van {total} apps het toegang tot ligging}other{# van {total} apps het toegang tot ligging}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Onlangse toegang"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Sien alles"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Bekyk besonderhede"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Geen programme het onlangs ligging versoek nie"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Geen programme het onlangs toegang tot jou ligging gekry nie"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Hoë batterygebruik"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Lae batterygebruik"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Wi‑Fi-opsporing"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Laat apps en dienste toe om enige tyd na Wi-Fi-netwerke te soek, selfs wanneer Wi-Fi af is. Dit kan byvoorbeeld gebruik word om ligginggegronde kenmerke en dienste te verbeter."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Bluetooth-opsporing"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Laat programme en dienste toe om enige tyd na toestelle in die omtrek te soek, selfs wanneer Bluetooth af is. Dit kan byvoorbeeld gebruik word om ligginggegronde kenmerke en dienste te verbeter."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Liggingdienste"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Liggingdienste"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Gebruik ligging"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Kan nie die tydsone outomaties stel nie"</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">"Ligging of Liggingdienste is af"</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">"Toestelligging word benodig"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"As jy jou ligging wil gebruik om die tydsone te stel, moet jy ligging aanskakel en dan tydsone-instellings opdateer"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Ligginginstellings"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Maak dit reg"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Kanselleer"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"Outomatiese tydsone is af"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Liggingtydsonebespeuring is gedeaktiveer"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"Liggingtydsonebespeuring word nie gesteun nie"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Veranderings aan liggingtydsonebespeuring word nie toegelaat nie"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Ligging kan gebruik word om tydsone te stel"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Sien regsinligting, status, sagteware-weergawe"</string>
    <string name="legal_information" msgid="7509900979811934843">"Regsinligting"</string>
    <string name="manual" msgid="3651593989906084868">"Handleiding"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Regulerende etikette"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Veiligheid- en regulatiewe handleiding"</string>
    <string name="copyright_title" msgid="83245306827757857">"Kopiereg"</string>
    <string name="license_title" msgid="8745742085916617540">"Lisensie"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Google Play-stelselopdateringlisensies"</string>
    <string name="terms_title" msgid="2071742973672326073">"Bepalings en voorwaardes"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Stelsel se WebView-lisensie"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Muurpapierkrediete"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Verskaffers van satellietbeelde:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Handleiding"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Kon nie die handleiding laai nie."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Derdepartylisensies"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Daar was \'n probleem om lisensies te loods."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Laai tans…"</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Laai tans…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Stel \'n wagwoord"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Stel \'n werkwagwoord"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Stel \'n PIN"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Stel \'n werk-PIN"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Stel \'n patroon"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Stel ’n patroon om die toestel te ontsluit vir bykomende sekuriteit"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Stel \'n werkpatroon"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Stel wagwoord vir vingerafdruk"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Stel patroon vir vingerafdruk"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Stel PIN vir sekuriteit"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Stel PIN vir vingerafdruk"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Voer jou wagwoord weer in"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Voer jou werkwagwoord weer in"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Voer jou werkwagwoord in"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Bevestig jou patroon"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Voer jou werkpatroon in"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Voer jou PIN weer in"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Voer jou werk-PIN weer in"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Voer jou werk-PIN in"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Wagwoorde verskil"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"PIN\'e stem nie ooreen nie"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Teken weer jou patroon"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Ontsluitmetode"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Wagwoord is gestel"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"PIN is gestel"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Patroon is ingestel"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Stel wagwoord om Gesigslot te gebruik"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Stel patroon om Gesigslot te gebruik"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Stel PIN om Gesigslot te gebruik"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Stel \'n wagwoord om gesig of vingerafdruk te gebruik"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Stel \'n patroon om gesig of vingerafdruk te gebruik"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Stel \'n PIN om gesig of vingerafdruk te gebruik"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Jou wagwoord vergeet?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Jou patroon vergeet?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Jou PIN vergeet?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7401165571170203743">"Teken jou patroon om voort te gaan"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Voer jou PIN in om voort te gaan"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Voer jou wagwoord in om voort te gaan"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Teken jou werkpatroon om voort te gaan"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Voer jou werk-PIN in om voort te gaan"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Voer jou werkwagwoord in om voort te gaan"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Gebruik jou toestelpatroon vir bykomende sekuriteit"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Voer jou toestel-PIN in vir bykomende sekuriteit"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Voer jou toestelwagwoord in vir bykomende sekuriteit"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Gebruik jou werkpatroon vir bykomende sekuriteit"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Voer jou werk-PIN in vir bykomende sekuriteit"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Voer jou werkwagwoord in vir bykomende sekuriteit"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Verifieer patroon"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Verifieer PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Verifieer wagwoord"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Verifieer dis jy"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Voer jou ander toestel se patroon in om Google-rekeninge, -instellings en meer oor te dra. Jou patroon is geënkripteer."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Voer jou ander toestel se PIN in om Google-rekeninge, -instellings en meer oor te dra. Jou PIN is geënkripteer."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Voer jou ander toestel se wagwoord in om Google-rekeninge, -instellings en meer oor te dra. Jou wagwoord in geënkripteer."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Gebruik ook patroon om dié toestel te ontsluit"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Gebruik ook PIN om dié toestel te ontsluit"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Gebruik ook wagwoord om dié toestel te ontsluit"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Verifieer patroon"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"Verifieer PIN"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Verifieer wagwoord"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Gebruik jou toestelpatroon om voort te gaan"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Voer jou toestel-PIN in om voort te gaan"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Voer jou toestelwagwoord in om voort te gaan"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"Verkeerde PIN"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Verkeerde wagwoord"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Verkeerde patroon"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Noodgeval"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Toestelsekuriteit"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Verander ontsluitpatroon"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Verander ontsluit-PIN"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Teken \'n ontsluitpatroon"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Druk Kieslys vir hulp."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Lig vinger op wanneer jy klaar is"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Verbind minstens <xliff:g id="NUMBER">%d</xliff:g> kolletjies. Probeer weer."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Patroon opgeneem"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Teken patroon weer om te bevestig"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Jou nuwe ontsluitpatroon"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Bevestig"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Teken oor"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Vee uit"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Gaan voort"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Ontsluitpatroon"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Benodig patroon"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Moet patroon teken om skerm te ontsluit"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Maak patroon sigbaar"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Verbeterde PIN-privaatheid"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Deaktiveer animasies terwyl jy die PIN invoer"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Maak profielpatroon sigbaar"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibreer met tik"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Kragknoppie sluit onmiddellik"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Behalwe as <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> dit ontsluit hou"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Stel ontsluitpatroon"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Verander ontsluitpatroon"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Hoe om \'n ontsluitpatroon te teken"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Te veel verkeerde pogings. Probeer oor <xliff:g id="NUMBER">%d</xliff:g> sekondes weer."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"Die program is nie op jou foon geïnstalleer nie."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Werkprofielsekuriteit"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Werkprofiel se skermslot"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Gebruik een slot"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Gebruik een slot vir werkprofiel en toestelskerm"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Gebruik een slot?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Jou toestel sal jou werkprofiel se skermslot gebruik. Werkbeleide sal op albei slotte van toepassing wees."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Jou werkprofielslot voldoen nie aan jou organisasie se sekuriteitsvereistes nie. Jy kan dieselfde slot vir jou toestelskerm en jou werkprofiel gebruik, maar alle werkskermslotbeleide sal van toepassing wees."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Gebruik een slot"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Gebruik een slot"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Dieselfde as toestelskermslot"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Bestuur programme"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Programinligting"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Program-instellings"</string>
    <string name="install_applications" msgid="3921609656584369901">"Onbekende bronne"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Laat alle programbronne toe"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Programme wat onlangs oopgemaak is"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Sien alle apps}other{Sien al # apps}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Kontak jou IT-administrateur"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Hulle kan jou help om jou PIN, patroon of wagwoord terug te stel"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Gevorderde instellings"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Aktiveer meer instellingsopsies"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Programinligting"</string>
    <string name="storage_label" msgid="2522307545547515733">"Berging"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Maak by verstek oop"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Verstekke"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Skermversoenbaarheid"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Toestemmings"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Kasgeheue"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Maak kas skoon"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Kasgeheue"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 item}other{# items}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Maak toegang skoon"</string>
    <string name="controls_label" msgid="8671492254263626383">"Kontroles"</string>
    <string name="force_stop" msgid="2681771622136916280">"Forseer stop"</string>
    <string name="archive" msgid="9074663845068632127">"Argiveer"</string>
    <string name="restore" msgid="7622486640713967157">"Stel terug"</string>
    <string name="restoring_step_one" msgid="3465050101254272874">"Stel tans terug"</string>
    <string name="restoring_step_two" msgid="140484846432595108">"Stel tans terug."</string>
    <string name="restoring_step_three" msgid="3712883580876329811">"Stel tans terug …"</string>
    <string name="restoring_step_four" msgid="8966846882470446209">"Stel tans terug …"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Totaal"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Programgrootte"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"USB-berging-program"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Gebruikerdata"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Verwyder"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Deïnstalleer vir alle gebruikers"</string>
    <string name="install_text" msgid="4558333621516996473">"Installeer"</string>
    <string name="disable_text" msgid="5146002260857428005">"Deaktiveer"</string>
    <string name="enable_text" msgid="8570798764647110430">"Aktiveer"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Vee berging uit"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Deïnstalleer opdaterings"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Laat beperkte instellings toe"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Sommige aktiwiteite wat jy gekies het, maak by verstek in hierdie program oop."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Jy het gekies om toe te laat dat hierdie program legstukke skep en by hulle data ingaan."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Verstek instellings nie opgestel nie."</string>
    <string name="clear_activities" msgid="488089228657585700">"Vee verstekvoorkeure uit"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Hierdie program is dalk nie vir jou skerm ontwerp nie; jy kan hier beheer hoe dit by jou skerm aanpas."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Vra wanneer laat loop word"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Skaleer program"</string>
    <string name="unknown" msgid="8192160131923461175">"Onbekend"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Rangskik volgens naam"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Rangskik volgens grootte"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Mees onlangse"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Mees gereelde"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Wys lopende dienste"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Wys gekaste prosesse"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Noodprogram"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Stel programvoorkeure terug"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Stel programvoorkeure terug?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Dit sal alle voorkeure terugstel vir:\n\n"<li>"Gedeaktiveerde programme"</li>\n<li>"Gedeaktiveerde programkenisgewings"</li>\n<li>"Verstekprogramme vir handelinge"</li>\n<li>"Agtergronddatabeperkings vir programme"</li>\n<li>"Enige toestemmingbeperkings"</li>\n<li>"Batterygebruikinstellings"</li>\n\n"Jy sal nie enige programdata verloor nie."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Stel programme terug"</string>
    <string name="filter" msgid="9039576690686251462">"Filter"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Kies filteropsies"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Alle apps"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Gedeaktiveerde programme"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Afgelaai"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Loop tans"</string>
    <string name="not_installed" msgid="5074606858798519449">"Nie vir hierdie gebruiker geïnstalleer nie"</string>
    <string name="installed" msgid="2837449358488825884">"Geïnstalleer"</string>
    <string name="no_applications" msgid="985069304755391640">"Geen programme nie"</string>
    <string name="internal_storage" msgid="999496851424448809">"Interne berging"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Herbereken tans grootte…"</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Vee programdata uit?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Hierdie program se data, insluitend lêers en instellings, sal permanent op hierdie toestel uitgevee word"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"OK"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Kanselleer"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Vee uit"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"Die program is nie in die lys geïnstalleerde programme gevind nie."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Kon nie berging vir program uitvee nie."</string>
    <string name="computing_size" msgid="4915310659841174866">"Bereken tans..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Kon nie pakketgrootte bereken nie."</string>
    <string name="version_text" msgid="7628938665256107608">"weergawe <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Skuif"</string>
    <string name="archiving_failed" msgid="2037798988961634978">"Kon nie argiveer nie"</string>
    <string name="archiving_succeeded" msgid="7891249456483297845">"<xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> is geargiveer"</string>
    <string name="restoring_failed" msgid="3390531747355943533">"Kon nie terugstel nie"</string>
    <string name="restoring_in_progress" msgid="7787443682651146115">"<xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> word teruggestel"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"\'n Ander migrasie is reeds aan die gang."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Nie genoeg stoorplek nie."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"Program bestaan ​​nie."</string>
    <string name="invalid_location" msgid="8013853455355520557">"Installeer-ligging is nie geldig nie."</string>
    <string name="system_package" msgid="7559476279008519360">"Stelselopdaterings kan nie op eksterne media geïnstalleer word nie."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Toesteladministrasieprogram kan nie op eksterne media geïnstalleer word nie"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Dwing stop?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"As jy \'n program dwing om te stop, kan dit wangedra."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Deaktiveer program"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"As jy hierdie program deaktiveer, sal Android en ander programme dalk nie meer soos bedoel werk nie. Hou in gedagte dat jy nie hierdie program kan uitvee nie, want dit is vooraf op jou toestel geïnstalleer. Deur dit te deaktiveer, skakel jy hierdie program af en versteek jy dit op jou toestel."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Winkel"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Programbesonderhede"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"Program is vanaf <xliff:g id="APP_STORE">%1$s</xliff:g> geïnstalleer"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Meer inligting oor <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Loop tans"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nooit gebruik nie)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Geheuegebruik"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Begin weer"</string>
    <string name="cached" msgid="5379485147573438201">"Gekaste agtergrondprosesse"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Niks loop nie."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Begin deur program"</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> beskikbaar"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> gebruik"</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">"Gebruiker: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Verwyderde gebruiker"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proses en <xliff:g id="NUMSERVICES">%2$d</xliff:g> diens"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proses en <xliff:g id="NUMSERVICES">%2$d</xliff:g> dienste"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> prosesse en <xliff:g id="NUMSERVICES">%2$d</xliff:g> diens"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> prosesse en <xliff:g id="NUMSERVICES">%2$d</xliff:g> dienste"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Toestelberging"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Program se RAM-gebruik"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Stelsel"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Programme"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Gratis"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Gebruik"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Gekas"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> van RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Lopende program"</string>
    <string name="no_services" msgid="3898812785511572899">"Onaktief"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Dienste"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Prosesse"</string>
    <string name="service_stop" msgid="5712522600201308795">"Stop"</string>
    <string name="service_manage" msgid="3896322986828332075">"Instellings"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Hierdie diens is deur sy program begin. As dit gestop word, kan die program misluk."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Hierdie program kan nie met veiligheid gestop word nie. As jy dit stop, kan jy sommige van jou huidige werk verloor."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Dit is \'n ou programproses wat nog steeds loop ingeval dit weer benodig word. Daar is gewoonlik geen rede om dit te stop nie."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: word tans gebruik. Tik op Instellings om dit te beheer."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Hoofproses wat gebruik word."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"Diens <xliff:g id="COMP_NAME">%1$s</xliff:g> word tans gebruik."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"Veskaffer <xliff:g id="COMP_NAME">%1$s</xliff:g> word tans gebruik."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Stop stelseldiens?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Tale, invoer en gebare"</string>
    <string name="language_settings" msgid="8700174277543875046">"Tale en invoer"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Tale"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Sleutelbord"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"Jy het nie toestemming om die toesteltaal te verander nie."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Tale en invoer"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Nutsgoed"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Sleutelbord en invoermetodes"</string>
    <string name="system_language" msgid="1146762166579643257">"Stelseltale"</string>
    <string name="phone_language" msgid="5986939176239963826">"Tale"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Outo-vervang"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Korrigeer die woorde wat verkeerd ingesleutel is"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Outohoofletters"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Begin sinne met \'n hoofletter"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Outo-leestekens"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Fisiese sleutelbordinstellings"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Druk spasie-sleutel twee keer om \".\" in te voeg"</string>
    <string name="show_password" msgid="7101900779571040117">"Wys wagwoorde"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Wys karakters kortliks terwyl jy tik"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Hierdie speltoetser is dalk in staat om al die teks wat jy invoer te versamel, insluitend persoonlike inligting soos wagwoorde en kredietkaartnommers. Dit kom van die <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>-program. Gebruik hierdie speltoetser?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Instellings"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Taal"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Sleutelborde"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Sleutelbord op skerm"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Beskikbare skermsleutelbord"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Bestuur sleutelborde op die skerm"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Opsies"</string>
    <string name="keyboard_a11y_category" msgid="8230758278046841469">"Toeganklikheid"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Fisiese sleutelbord"</string>
    <string name="show_ime" msgid="4334255501724746849">"Gebruik skermsleutelbord"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Hou dit op die skerm terwyl fisieke sleutelbord aktief is"</string>
    <string name="bounce_keys" msgid="7419450970351743904">"Hopsleutels"</string>
    <!-- no translation found for bounce_keys_summary (7347050868868080302) -->
    <skip />
    <string name="slow_keys" msgid="2891452895499690837">"Stadige sleutels"</string>
    <!-- no translation found for slow_keys_summary (1784371292745423292) -->
    <skip />
    <string name="sticky_keys" msgid="7317317044898161747">"Taaisleutels"</string>
    <!-- no translation found for sticky_keys_summary (1844953803625480623) -->
    <skip />
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Kortpadsleutels"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Wys lys met kortpaaie"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Werkprofielsleutelborde en -nutsgoed"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Skermsleutelbord vir werk"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Verstek"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Raakpaneel"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Raakpaneel en muis"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Wyserspoed, gebare"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Tik om te klik"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Raakpaneelgebare"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Pasmaak individuele raakpaneelnavigasiegebare"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Omgekeerde rollees"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"Inhoud beweeg op wanneer jy ondertoe rollees"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Tik onder regs"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Tik op die raakpaneel se hoek onder regs vir meer opsies"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Wyserspoed"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Leer raakpaneelgebare"</string>
    <string name="keywords_touchpad" msgid="8159846254066666032">"stuurpaneel, stuurpaneel, muis, skermpyltjie, rollees, swiep, regsklik, klik, wyser"</string>
    <string name="keywords_trackpad_bottom_right_tap" msgid="1285062446073929305">"regsklik, tik"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Gaan na tuisskerm"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Swiep op met drie vingers enige plek op jou raakpaneel"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Gaan terug"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Swiep met drie vingers van links of regs"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Bekyk onlangse apps"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Swiep op met drie vingers, hou en laat los dan"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Bekyk kennisgewings en Kitsinstellings"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Swiep af met drie vingers op jou tuisskerm"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Wissel apps"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Swiep met vier vingers links of regs"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Slaan oor"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Volgende"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Herbegin"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Klaar"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Gaan terug"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Swiep met drie vingers links of regs"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Gaan na tuisskerm"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Swiep met drie vingers op"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Onlangse apps"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Swiep met drie vingers op, en hou dan"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Kennisgewings"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Swiep met drie vingers af"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Wissel apps"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Swiep met vier vingers links of regs"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Wysigersleutels"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Verander hoe sleutels optree"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Stel alles terug"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Verstek"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Is jy seker jy wil al die wysigersleutels na hul verstek toe terugstel?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Klaar"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Kanselleer"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Stel terug"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Kies wysigersleutel"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Kies ’n nuwe sleutel vir <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Verstek"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Spraak"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Wyserspoed"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Speletjiekontroleerder"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Herlei vibrasie"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Stuur vibrasie na speletjiebeheerder wanneer dit gekoppel is"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Kies sleutelborduitleg"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Stel sleutelborduitlegte op"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Om te wissel, druk Control-spasiebalk"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Verstek"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Sleutelborduitlegte"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Uitlegte van fisieke sleutelborde"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Persoonlike woordeboek"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Persoonlike woordeboek vir werk"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Voeg woorde by wat in programme soos Speltoetser gebruik sal word"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Voeg by"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Voeg by woordeboek"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Frase"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Meer opsies"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Minder opsies"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Woord:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Kortpad:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Taal:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Tik \'n woord in"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Opsionele kortpad"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Redigeer woord"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Redigeer"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Vee uit"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Jy het geen woorde in die gebruikerwoordeboek nie. Tik op die Voeg By-knoppie (+) om \'n woord by te voeg."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Vir alle tale"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Meer tale..."</string>
    <string name="testing" msgid="6294172343766732037">"Toets"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Skermsleutelbord, nutsgoed"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Skermsleutelbord, fisieke sleutelbord, nutsgoed"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Fisiese sleutelbord"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Uitleg"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Kies apparaat"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Kies legstuk"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Skep legstuk en laat toegang toe?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Nadat jy die legstuk geskep het, kan die program toegang kry tot alles wat vertoon word.\n\nProgram: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nLegstuk: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Laat <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> altyd toe om legstukke te skep en om by hul data in te gaan."</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Gebruikstatistieke"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Sorteer volgens gebruikstyd"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Sorteer volgens laas gebruik"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Sorteer volgens programnaam"</string>
    <string name="last_time_used_label" msgid="7589377271406011659">"Laas gebruik"</string>
    <string name="last_time_used_never" msgid="2936073559267990034">"nooit"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Gebruikstyd"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Toeganklikheid"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Toeganklikheids-instellings"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Skerm, interaksie, oudio"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Visie-instellings"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Jy kan hierdie toestel pasmaak om by jou behoeftes te pas. Hierdie toeganklikheidkenmerke kan later in Instellings verander word."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Verander lettergrootte"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Skermleser"</string>
    <!-- no translation found for keyboard_category_title (6841712758039893220) -->
    <skip />
    <string name="captions_category_title" msgid="574490148949400274">"Onderskrifte"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Oudio"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Algemeen"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Vertoon"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Kleur en beweging"</string>
    <!-- no translation found for accessibility_color_contrast_title (5757724357142452378) -->
    <skip />
    <!-- no translation found for accessibility_color_contrast_intro (7795090401101214930) -->
    <skip />
    <!-- no translation found for color_contrast_note (7592686603372566198) -->
    <skip />
    <!-- no translation found for accessibility_color_contrast_summary (7563237683500106632) -->
    <skip />
    <!-- no translation found for color_contrast_preview (6791430227535363883) -->
    <skip />
    <!-- no translation found for color_contrast_preview_sender_name (8641943417589238147) -->
    <skip />
    <!-- no translation found for color_contrast_preview_email_send_date (2108702726171600080) -->
    <skip />
    <!-- no translation found for color_contrast_preview_email_badge (4845484039428505392) -->
    <skip />
    <!-- no translation found for color_contrast_preview_email_title (198712116139754823) -->
    <skip />
    <!-- no translation found for color_contrast_preview_email_body (4139331665325624199) -->
    <skip />
    <!-- no translation found for color_contrast_preview_email_attachment_name (852407311884814746) -->
    <skip />
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Maak skerm donkerder"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Interaksiekontroles"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Tydkontroles"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Stelselkontroles"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Afgelaaide program"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Eksperimenteel"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Kenmerkvlae"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Bluetooth HCI-oorsendingloglêerfiltrering"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Stel filters"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Deaktiveer en aktiveer Bluetooth sodat die veranderinge in werking kan tree"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"Bluetooth HCI-oorsendingloglêerfiltrering van PBAP"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"Bluetooth HCI-oorsendingloglêerfiltrering van MAP"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Stel filtreermodus. (Deaktiveer en aktiveer Bluetooth sodat die veranderinge in werking kan tree)"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Stel Bluetooth HCI-oorsendingloglêermodus op Filter Geaktiveer om hierdie opsie te verander"</string>
    <string name="talkback_title" msgid="8756080454514251327">"TalkBack"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Skermleser hoofsaaklik vir mense wat blind of swaksiende is"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Tik op items op jou skerm om te hoor hoe hulle hardop gelees word"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Onderskrifvoorkeure"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Meer oor onderskrifvoorkeure"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Kom meer te wete oor onderskrifvoorkeure"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Vergroting"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Vergrotingkortpad"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Vergroot tikwerk"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"Vergrootglas volg teks terwyl jy tik"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Hou aan terwyl apps gewissel word"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"Vergrootglas bly aan en zoem uit wanneer jy apps wissel"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Speelstok"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Aktiveer en skuif die vergrootglas met ’n speelstok op die skerm. Tik en hou die speelstok, en sleep dit dan om die vergrootglas te beheer. Tik en sleep om die speelstok self te skuif."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Meer oor vergroting"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Kom meer te wete oor vergroting"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Vergrotingtipe"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Vergroot jou hele skerm of \'n spesifieke area, of wissel tussen die twee opsies"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Volskerm"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Gedeeltelike skerm"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Wissel tussen vol- en gedeeltelike skerm"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Kies hoe om te vergroot"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Vergroot die hele skerm"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Vergroot deel van skerm"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Wissel tussen vol- en gedeeltelike skerm"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Tik op die wisselknoppie om tussen albei opsies te wissel"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Skakel oor na toeganklikheidknoppie?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"As tripeltik gebruik word om \'n deel van jou skerm te vergroot, kan dit invoer- en ander vertragings veroorsaak.\n\nDie toeganklikheidknoppie sweef op jou skerm oor ander programme. Tik dit om te vergroot."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Skakel oor na toeganklikheidknoppie"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Gebruik tripeltik"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Dit kan jou sleutelbord stadiger maak"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"As jy tripeltik gebruik om deel van jou skerm te vergroot, kan jy dalk opmerk dat daar probleme met die sleutelbord is.\n\nOm dit te vermy, kan jy jou vergrotingkortpad van tripeltik na ’n ander opsie verander.\n"<annotation id="link">"Verander instelling"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Gaan in elk geval voort"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Kanselleer"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Vergrotinginstellings"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Vergroot met kortpad"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Vergroot met kortpad en trippeltik"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Meer oor <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Skermgrootte en teks"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Verander hoe teks gewys word"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Onderwerp: Ontwerpe vir warmlugballonne"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"Van: Bill"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Goeiemôre!\n\nEk wil net uitvind hoe die ontwerpe vorder. Sal hulle gereed wees voordat ons die nuwe ballonne begin bou?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Stel instellings terug"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Skermgrootte- en teksinstellings is teruggestel"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Stel skermgrootte en teks terug?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Stel terug"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Enige naweekplanne?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Op pad strand toe. Wil jy saamgaan?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Opsies"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Zoem in op skerm"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Tik 3 keer om te zoem"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Tik op \'n knoppie om te zoem"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Zoem vinnig op die skerm in om inhoud groter te maak"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Zoem só in:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Gebruik kortpad om vergroting te begin&lt;br/&gt; {1,number,integer}. Tik op die skerm&lt;br/&gt; {2,number,integer}. Sleep 2 vingers om op die skerm rond te beweeg&lt;br/&gt; {3,number,integer}. Knyp met 2 vingers om die zoem te verstel&lt;br/&gt; {4,number,integer}. Gebruik kortpad om vergroting te stop&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Zoem só tydelik in:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Maak seker dat jou vergrotingtipe op volskerm gestel is&lt;br/&gt; {1,number,integer}. Gebruik kortpad om vergroting te begin&lt;br/&gt; {2,number,integer}. Raak en hou enige plek op die skerm&lt;br/&gt; {3,number,integer}. Sleep vinger om op die skerm rond te beweeg&lt;br/&gt; {4,number,integer}. Lig vinger om vergroting te stop"</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Wanneer vergroting aangeskakel is, kan jy op jou skerm inzoem.\n\n"<b>"Om te zoem"</b>", moet jy vergroting begin en dan op enige plek op die skerm tik.\n"<ul><li>"Sleep 2 of meer vingers om te rollees"</li>\n<li>"Knyp 2 of meer vingers om zoem te verstel"</li></ul>\n\n<b>"Om tydelik te zoem"</b>", moet jy vergroting begin en dan enige plek op die skerm raak en hou.\n"<ul><li>"Sleep om op die skerm rond te beweeg"</li>\n<li>"Lig jou vinger op om uit te zoem"</li></ul>\n\n"Jy kan nie op die sleutelbord of die navigasiebalk inzoem nie."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Bladsy <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> van <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Gebruik toeganklikheidknoppie om oop te maak"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Hou volumesleutels om oop te maak"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Tripeltik op skerm om oop te maak"</string>
    <string name="accessibility_tutorial_dialog_title_two_finger_double" msgid="3912970760484557646">"Tweevinger-dubbeltik op skerm om oop te maak"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Gebruik gebaar om oop te maak"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Gebruik toeganklikheidsgebaar"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Tik op die toeganklikheidknoppie <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> onderaan jou skerm om hierdie kenmerk te gebruik.\n\nRaak en hou die toeganklikheidknoppie om tussen kenmerke te wissel."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Tik op die toeganklikheidknoppie op jou skerm om hierdie kenmerke te gebruik."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Druk en hou albei volumesleutels om hierdie kenmerk te gebruik."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Tripeltik enige plek op jou skerm om vergroting te begin en te stop."</string>
    <string name="accessibility_tutorial_dialog_message_two_finger_triple" msgid="860548190334486449">"Dubbeltik met twee vingers enige plek op jou skerm om vergroting te begin en te stop."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Swiep met 2 vingers van die onderkant van die skerm af op om hierdie kenmerk te gebruik.\n\nSwiep met 2 vingers op en hou om tussen kenmerke te wissel."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Swiep met 3 vingers van die onderkant van die skerm af op om hierdie kenmerk te gebruik.\n\nSwiep met 3 vingers op en hou om tussen kenmerke te wissel."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Swiep met 2 vingers van die onderkant van die skerm af op om \'n toeganklikheidkenmerk te gebruik.\n\nSwiep met 2 vingers op en hou om tussen kenmerke te wissel."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Swiep met 3 vingers van die onderkant van die skerm af op om \'n toeganklikheidkenmerk te gebruik.\n\nSwiep met 3 vingers op en hou om tussen kenmerke te wissel."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Het dit"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="6797349445794031781">"Knoppie-instellings"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"<xliff:g id="SERVICE">%1$s</xliff:g>-kortpad"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Toeganklikheidknoppie"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Toeganklikheidsgebaar"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Swiep op met 2 vingers"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Swiep op met 3 vingers"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Tik op toeganklikheidknoppie"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Gebruik toeganklikheidsgebaar"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Tik op die toeganklikheidknoppie <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> aan die onderkant van jou skerm.\n\nRaak en hou die toeganklikheidknoppie om tussen kenmerke te wissel."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Swiep met 2 vingers van die onderkant van die skerm af op.\n\nSwiep op met 2 vingers en hou om tussen kenmerke te wissel."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Swiep met 3 vingers van die onderkant van die skerm af op.\n\nSwiep op met 3 vingers en hou om tussen kenmerke te wissel."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Meer opsies"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Kom meer te wete oor <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Hou volumesleutels in"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"hou volumesleutels"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Druk en hou albei volumesleutels"</string>
    <string name="accessibility_shortcut_edit_dialog_title_two_finger_double_tap" msgid="2271778556854020996">"Tweevinger-dubbeltik op skerm"</string>
    <string name="accessibility_shortcut_two_finger_double_tap_keyword" msgid="2971265341474137433">"tweevinger-dubbeltik op skerm"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_two_finger_double_tap" msgid="8262165091808318538">"Tik vinnig {0,number,integer} keer op die skerm met twee vingers"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Tik 3 keer op skerm"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"tripeltik op skerm"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Tik {0,number,integer} keer vinnig op skerm. Hierdie kortpad kan jou toestel stadiger maak"</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Gevorderd"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"Die Toeganklikheidsknoppie is gestel op <xliff:g id="SERVICE">%1$s</xliff:g>. Raak en hou die Toeganklikheidsknoppie en kies vergroting as jy vergroting wil gebruik."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"Die toeganklikheidgebaar is gestel op die <xliff:g id="SERVICE">%1$s</xliff:g>. Swiep met twee vingers op van die onderkant van die skerm af en hou om vergroting te gebruik. Kies dan vergroting."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Volumesleutelkortpad"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Kortpadinstellings"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Kortpad van sluitskerm af"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Laat toe dat kenmerkkortpad van die sluitskerm af aangeskakel word. Hou albei volumesleutels \'n paar sekondes lank."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Toeganklikheidknoppie"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Toeganklikheidsknoppie en -gebaar"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Kry van enige skerm af vinnig toegang tot toeganklikheidskenmerke"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Meer oor toeganklikheidknoppie"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Meer oor toeganklikheidknoppie en -gebaar"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Kom meer te wete oor toeganklikheidknoppie en -gebaar"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Gebruik tans toeganklikheidsknoppie. Die gebaar is nie beskikbaar met 3-knoppienavigasie nie."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Kry vinnig toegang tot toeganklikheidskenmerke"</string>
    <string name="accessibility_button_gesture_description" msgid="1141723096904904336">"&lt;b&gt;Om te begin&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Gaan na toeganklikheidsinstellings&lt;br/&gt; {1,number,integer}. Kies ’n kenmerk en tik op die kortpad&lt;br/&gt; {2,number,integer}. Kies of jy ’n knoppie of gebaar wil gebruik om toegang tot die kenmerk te kry&lt;br/&gt;"</string>
    <string name="accessibility_button_description" msgid="7669538706120092399">"&lt;b&gt;Om te begin&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Gaan na toeganklikheidsinstellings&lt;br/&gt; {1,number,integer}. Kies ’n kenmerk en tik op die kortpad&lt;br/&gt; {2,number,integer}. Kies die knoppie om toegang tot die kenmerk te kry&lt;br/&gt;"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Gebruik knoppie of gebaar"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Ligging"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Grootte"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Verdof wanneer dit nie gebruik word nie"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Verdof ná \'n paar sekondes sodat dit makliker is om jou skerm te sien"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Deursigtigheid wanneer nie gebruik word nie"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Deursigtig"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Ondeursigtig"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Hoëkontrasteks"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Verander tekskleur na swart of wit. Vergroot kontras met die agtergrond."</string>
    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_title (8737272017343509753) -->
    <skip />
    <!-- no translation found for accessibility_toggle_maximize_text_contrast_preference_summary (5493999083693403489) -->
    <skip />
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Dateer outomaties skermvergroting op"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Dateer skermvergroting op tydens programverwisseling"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Kragknoppie beëindig oproep"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Groot muiswyser"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Maak die muiswyser meer opmerklik"</string>
    <string name="accessibility_force_invert_title" msgid="5015366813138748407">"Maak alle apps donker"</string>
    <string name="accessibility_force_invert_summary" msgid="1882329675950887268">"Geld vir apps sonder hul eie donkertema. Sommige apps kan skermprobleme hê, soos omgekeerde kleure."</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Verwyder animasies"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Verminder beweging op die skerm"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Mono-oudio"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Kombineer kanale wanneer oudio gespeel word"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Oudiobalans"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Links"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Regs"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Verstek"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 sekondes"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 sekondes"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minuut"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minute"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Tyd vir aksie (toeganklikheiduittelling)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Meer oor Tyd vir Aksie (toeganklikheiduittelling)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Kom meer te wete oor Tyd vir Aksie (toeganklikheiduittelling)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Tyd om iets te doen"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Nie alle programme steun hierdie tydsduurvoorkeur nie"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Kies hoe lank om tydelike boodskappe te wys wat jou vra om iets te doen"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Raak-en-hou-vertraging"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Kleuromkering"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Gebruik kleuromkering"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Kleuromkeringkortpad"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"Kleuromkering maak ligte skerms donker. Dit maak ook donker skerms lig."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Hou in gedagte&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Kleure in media en prente sal verander&lt;/li&gt; &lt;li&gt; Kleuromkering werk in alle programme&lt;/li&gt; &lt;li&gt; Donkertema kan pleks daarvan gebruik word om ’n donker agtergrond te wys&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_action_label_panel_slice" msgid="1313725957071602932">"instellings in te voer"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Outoklik (stilstandtydtelling)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Oor outoklik (stilstandtydtelling)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Kom meer te wete oor outoklik (stilstandtydtelling)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Jy kan ’n gekoppelde muis stel om outomaties te klik wanneer die skermpyltjie ’n sekere tyd lank nie beweeg het nie"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"Outoklik kan nuttig wees as dit moeilik is om die muis te klik"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Outoklik is af"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Kort"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 sekondes"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Medium"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 sekondes"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Lank"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 sekonde"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Gepasmaak"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Korter"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Langer"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Outokliktyd"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibrasie en fisiese terugvoer"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Beheer die vibrasiesterkte vir verskillende gebruike"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Aan"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Af"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Instelling is gedeaktiveer omdat die toestel op stil gestel is"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Oproepe"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Kennisgewings en alarms"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Interaktiewe fisiese terugvoer"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Gebruik vibrasie en fisiese terugvoer"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Wekkervibrasie"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Mediavibrasie"</string>
    <string name="accessibility_keyboard_vibration_title" msgid="7559967730626765441">"Sleutelbordvibrasie"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Luivibrasie"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Kennisgewingvibrasie"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Raakterugvoer"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Gebruik <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Maak <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> oop"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"<xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> is by Kitsinstellings gevoeg. Swiep af om dit enige tyd aan of af te skakel."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Jy kan <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> ook van die bokant van jou skerm af by Kitsinstellings voeg"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Kleurregstelling is by Kitsinstellings gevoeg. Swiep af om dit enige tyd aan of af te skakel."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Jy kan kleurregstelling ook van die bokant van jou skerm af by Kitsinstellings voeg"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Kleuromkering is by Kitsinstellings gevoeg Swiep af om dit enige tyd aan of af te skakel."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Jy kan kleuromkering ook van die bokant van jou skerm af by Kitsinstellings voeg"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Ekstra donker is by Kitsinstellings gevoeg. Swiep af om dit enige tyd aan of af te skakel."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Jy kan ekstra donker ook van die bokant van jou skerm af by Kitsinstellings voeg"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Eenhandmodus is by Kitsinstellings gevoeg. Swiep af om dit enige tyd aan of af te skakel."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Jy kan eenhandmodus ook van die bokant van jou skerm af by Kitsinstellings voeg"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Lettertipegrootte is by Kitsinstellings gevoeg. Swiep af om enige tyd die lettertipegrootte te verander."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Maak toe"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Gebruik kleurregstelling"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Kleurregstellingkortpad"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Meer oor kleurregstelling"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Kom meer te wete oor kleurregstelling"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Meer oor kleuromkering"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Kom meer te wete oor kleuromkering"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Wys onderskrifte"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Net vir gesteunde program"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Grootte en styl van onderskrif"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"<xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g> teksgrootte"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Meer opsies"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Pasmaak onderskrifgrootte en -styl om hulle makliker te maak om te lees"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Nie alle mediaprogramme steun hierdie onderskrifvoorkeure nie"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Toeganklikheidknoppie"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Swiep met 2 vingers van onder na bo"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Hou volumesleutels in"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tripeltik op skerm"</string>
    <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Wysig toeganklikheidkortpaaie"</string>
    <!-- no translation found for accessibility_shortcut_edit_screen_prompt (5966054283114856682) -->
    <skip />
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Gaan voort"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Gehoortoestelle"</string>
    <!-- no translation found for accessibility_hearingaid_intro (6686620444104350629) -->
    <skip />
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Geen gehoortoestelle is gekoppel nie"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Voeg gehoortoestelle by"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Bind gehoortoestelle saam"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Tik op die volgende skerm op jou gehoortoestelle. Jy sal dalk die linker- en regteroor apart moet saambind.\n\nMaak seker dat jou gehoortoestelle aangeskakel en gereed is om saam te bind."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> is aktief"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, net linker"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, net regter"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, linker en regter"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> + nog 1"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Bind nuwe toestel saam"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Gehoortoestelle"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Gestoorde toestelle"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Gehoortoestelkontroles"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Gehoortoestelkortpad"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Gehoortoestelversoenbaarheid"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Verbeter versoenbaarheid met teleklosse en verminder ongewenste geraas"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Meer oor gehoortoestelle"</string>
    <!-- no translation found for accessibility_hearing_device_footer_summary (256061045064940818) -->
    <skip />
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Bind gehoortoestel saam"</string>
    <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Jy kan ASHA- en LE-oudio-gehoortoestelle op hierdie bladsy saambind. Maak seker dat jou gehoortoestel aangeskakel en gereed is om saam te bind."</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Beskikbare gehoortoestelle"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Sien nie jou gehoortoestel nie?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Sien meer toestelle"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Oudio-aanpassing"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Oudiobeskrywing"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Hoor \'n beskrywing van wat op die skerm gebeur in gesteunde flieks en programme"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"oudiobeskrywing, oudio, beskrywing, swak sig,"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Kortpad is aan"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Af"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Aan"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Af"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Werk nie. Tik vir inligting."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Hierdie diens werk nie."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Toeganklikheidskortpaaie"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Wys in Vinnige instellings"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Rooi-groen"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Rooi-groen"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Blou-geel"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Grysskaal"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Groen swak, deuteranomalie"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Rooi swak, protanomalie"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomalie"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Ekstra flou"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Maak skerm ekstra donker"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Ekstra Donker-kortpad"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Meer oor ekstra donker"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Maak jou skerm donkerder sodat dit gemakliker is om te lees"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensiteit"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Dowwer"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Helderder"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Hou aan nadat toestel herbegin het"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Kort ({time} sekonde)}other{Kort ({time} sekondes)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Medium ({time} sekonde)}other{Medium ({time} sekondes)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Lank ({time} sekonde)}other{Lank ({time} sekondes)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} sekonde}other{{time} sekondes}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Instellings"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Aan"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Af"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Voorskou"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Standaardopsies"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Taal"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Teksgrootte"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Onderskrifstyl"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Gepasmaakte opsies"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Agtergrondkleur"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Agtergrond-ondeursigtigheid"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Onderskrifvenster se kleur"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Onderskrifvenster se ondeursigtigheid"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Tekskleur"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Teksondeursigtigheid"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Randkleur"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Randtipe"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Letterfamilie"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Onderskrifte sal so lyk"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Verstek"</string>
    <string name="color_title" msgid="2511586788643787427">"Kleur"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Verstek"</string>
    <string name="color_none" msgid="3703632796520710651">"Geen"</string>
    <string name="color_white" msgid="1896703263492828323">"Wit"</string>
    <string name="color_gray" msgid="8554077329905747877">"Grys"</string>
    <string name="color_black" msgid="9006830401670410387">"Swart"</string>
    <string name="color_red" msgid="5210756997426500693">"Rooi"</string>
    <string name="color_green" msgid="4400462091250882271">"Groen"</string>
    <string name="color_blue" msgid="4997784644979140261">"Blou"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Siaan"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Geel"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Gee <xliff:g id="SERVICE">%1$s</xliff:g> volle beheer oor jou toestel?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> moet:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Instellings kan nie jou antwoord verifieer nie omdat \'n program \'n toestemmingversoek verberg."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> versoek tans volle beheer van hierdie toestel. Die diens kan die skerm lees en namens gebruikers met toeganklikheidsbehoeftes optree. Hierdie vlak van beheer is nie vir die meeste programme toepaslik nie."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"Volle beheer is gepas vir apps wat jou help met toeganklikheidsbehoeftes, maar nie vir die meeste apps nie."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Bekyk en beheer skerm"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Dit kan alle inhoud op die skerm lees en inhoud bo-oor ander apps vertoon."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Bekyk en voer handelinge uit"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Dit kan jou interaksies met \'n app of \'n hardewaresensor naspoor en namens jou met apps interaksie hê."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Laat toe"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Weier"</string>
    <string name="accessibility_dialog_button_stop" msgid="7584815613743292151">"Skakel af"</string>
    <string name="accessibility_dialog_button_cancel" msgid="8625997437316659966">"Hou aan"</string>
    <string name="disable_service_title" msgid="8178020230162342801">"Skakel <xliff:g id="SERVICE">%1$s</xliff:g> af?"</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Geen dienste geïnstalleer nie"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Geen diens is gekies nie"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Geen beskrywing verskaf nie."</string>
    <string name="settings_button" msgid="2195468788019730377">"Instellings"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"ligsensitiwiteit, fotofobie, donkertema, migraine, hoofpyn, leesmodus, nagmodus, verlaag helderheid, witpunt"</string>
    <string name="keywords_accessibility" msgid="8593989878379366798">"visie, gehoor, blind, doof, motories, handigheid, ondersteunend, bystand, gebruiksgemak, toegangsgemak, hand, hulp"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Venstervergrootglas, zoem, vergroting, swak sig, vergroot, maak groter"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Onderskrifte, onderskrifte, CC, kitstranskripsie, hardhorend, gehoorverlies, CART, spraak-na-teks, onderskrifte"</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">"skermgrootte, groot skerm"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Hoë kontras, swak sig, vetdruklettertipe, vetdruk"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"verstel kleur"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"maak skerm donker, maak skerm lig"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"kleurkontras"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="6811744211216280998">"motories, muis, eksterne muis, hoofmuis, aannpasbare muis, rolstoel, speelstok"</string>
    <string name="keywords_hearing_aids" msgid="4657889873249157071">"gehoortoestelle, hardhorend, gehoorverlies, kogleêre inplantings, klankversterkingtoestelle, klankverwerkers, PSAP"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"hardhorend, gehoorverlies, onderskrifte, telesetter, TTY"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="keywords_3_button_navigation" msgid="436361965016404218">"drie knoppies"</string>
    <string name="keywords_touch_and_hold_delay" msgid="7854640156419599912">"handigheid, motories, senior, artritis, rsi, beroerte, bewing, verspreide sklerose, serebrale verlamming, geskud, ooreisingbesering, hand"</string>
    <string name="keywords_accessibility_timeout" msgid="8903766864902000346">"vertraging, handigheid, senior"</string>
    <string name="print_settings" msgid="8519810615863882491">"Druk"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Af"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 drukdiens is aan}other{# drukdienste is aan}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 druktaak}other{# druktake}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Drukdienste"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Geen dienste geïnstalleer nie"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Geen drukkers gekry nie"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Instellings"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Voeg drukkers by"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Aan"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Af"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Voeg diens by"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Voeg drukker by"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Soek"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Soek tans vir drukkers"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Diens gedeaktiveer"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Uitdruktake"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Uitdruktaak"</string>
    <string name="print_restart" msgid="4424096106141083945">"Herbegin"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Kanselleer"</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">"Stel tans <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> op"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Druk tans <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Kanselleer tans <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Drukkerfout by <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"Drukker het <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g> geblokkeer"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Soekkassie vertoon"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Soekkassie weggesteek"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Meer inligting oor hierdie drukker"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Battery"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Wat het die battery gebruik"</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> oor"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> tot gelaai"</string>
    <string name="power_usage_detail_screen_time" msgid="6027274749498485283">"Skermtyd"</string>
    <string name="power_usage_detail_background_time" msgid="3661437083554322691">"Agtergrondtyd"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Lae battery"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Laat die program toe om in die agtergrond te loop"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Beperk agtergrondaktiwiteit?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"As jy agtergrondaktiwiteit vir \'n program beperk, kan dit verkeerd werk"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Hierdie program is nie gestel om batterykrag te optimeer nie en daarom kan jy dit nie beperk nie.\n\nOm die program te beperk, moet jy eers batterykrag-optimering aanskakel."</string>
    <string name="manager_battery_usage_category_title" msgid="1493303237531629961">"Bestuur batterygebruik"</string>
    <string name="manager_battery_usage_allow_background_usage_title" msgid="6294649996820358852">"Laat agtergrondgebruik toe"</string>
    <string name="manager_battery_usage_allow_background_usage_summary" msgid="8021153755201340819">"Aktiveer vir intydse opdaterings, deaktiveer om battery te spaar"</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Onbeperk"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Geoptimeer"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Beperk"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Laat batterygebruik op die agtergrond sonder beperkings toe. Sal dalk meer batterykrag gebruik."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimeer op grond van jou gebruik. Aanbeveel vir die meeste programme."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Beperk batterygebruik terwyl dit op die agtergrond is. Program sal dalk nie werk soos verwag nie. Kennisgewings kan vertraag word."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"\'n Program se werkverrigting kan geraak word as jy verander hoe dit jou battery gebruik."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Hierdie program vereis <xliff:g id="STATE">%1$s</xliff:g> batterygebruik."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"onbeperkte"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"geoptimeerde"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Kom meer te wete oor batterygebruikopsies"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Skermgebruik sedert battery volgelaai is"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Batterygebruik"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Geskiedenisdetails"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Batterygebruik"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Bekyk gebruik in die afgelope 24 uur"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Bekyk gebruik sedert battery laas volgelaai is"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Programbatterygebruik"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Gebruikdetails"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Verstel kraggebruik"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Ingeslote pakkette"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Programme werk normaal"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Batteryvlak is laag"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Skakel Batterybespaarder aan om batterylewe te verleng"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Verbeter batterylewe"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Skakel Batterybestuurder aan"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Skakel Batterybespaarder aan"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"Battery kan gouer as gewoonlik afloop"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Batterybespaarder is aan"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Kom meer te wete oor Batterybespaarder"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Sommige kenmerke kan beperk word"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Hoër battery gebruik"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Sien programme met die hoogste gebruik"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Laaiproses word geoptimeer om jou battery te beskerm"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Laaiproses is geoptimeer om jou battery se lewensduur te help verleng"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Kom meer te wete oor laaiproses wat onderbreek is"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Hervat laaiproses"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Sluit hoëkrag-agtergrondaktiwiteit in"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Beperk # app}other{Beperk # apps}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} is onlangs beperk}other{# apps is onlangs beperk}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} se agtergrondbatterygebruik is hoog}other{# apps se agtergrondbatterygebruik is hoog}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Hierdie app kan nie op die agtergrond loop nie}other{Hierdie apps kan nie op die agtergrond loop nie}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Beperk app?}other{Beperk # apps?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Verhoed <xliff:g id="APP">%1$s</xliff:g> om die battery op die agtergrond te gebruik om so batterykrag te bespaar. Hierdie program sal dalk nie behoorlik werk nie en kennisgewings sal dalk vertraag word."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Verhoed hierdie programme om die battery op die agtergrond te gebruik om so batterykrag te bespaar. Beperkte programme sal dalk nie behoorlik werk nie en kennisgewings sal dalk vertraag word.\n\nProgramme:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Verhoed hierdie programme om die battery op die agtergrond te gebruik om so batterykrag te bespaar. Beperkte programme sal dalk nie behoorlik werk nie en kennisgewings sal dalk vertraag word.\n\nProgramme:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Beperk"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"Verwyder beperking?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Hierdie program sal batterykrag op die agtergrond kan gebruik. Jou battery sal dalk gouer as verwag afloop."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Verwyder"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Kanselleer"</string>
    <string name="battery_tip_charge_to_full_button" msgid="9172893341338732733">"Ignoreer"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="1567827436103364999">"Gaan die laaibykomstigheid na"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Kom meer te wete oor onversoenbare laaiproses"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Batterybestuurder"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Bestuur programme outomaties"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Wanneer Batterybestuurder bespeur dat programme jou battery leegmaak, het jy die opsie om daardie programme te beperk. Beperkte programme sal dalk nie behoorlik werk nie en kennisgewings sal dalk vertraag word."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Beperkte programme"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Beperk tans batterygebruik vir # app}other{Beperk tans batterygebruik vir # apps}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Beperk: <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Hierdie programme word weerhou daarvan om agtergrondbattery te gebruik. Hulle sal dalk nie werk soos verwag nie en kennisgewings kan dalk vertraag word."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Gebruik Batterybestuurder"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Bespeur wanneer programme battery leegmaak"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Bespeur wanneer programme battery leegmaak"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Bespeur wanneer programme battery leegmaak"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# app is beperk}other{# apps is beperk}}"</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">"Kon nie die batterymeter lees nie."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Tik om meer oor hierdie fout te wete te kom"</string>
    <string name="power_screen" msgid="4596900105850963806">"Skerm"</string>
    <string name="power_cpu" msgid="1820472721627148746">"CPU"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Flitslig"</string>
    <string name="power_camera" msgid="4778315081581293923">"Kamera"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Selnetwerk"</string>
    <string name="power_phone" msgid="2768396619208561670">"Stemoproepe"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Skermgebruik <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> gebruik deur <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> van algehele batterygebruik"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Ontleding sedert battery laas volgelaai is"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Laas volgelaai"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"Volgelaaide battery hou omtrent"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"Oorblywende batterylewe is benaderd en kan op grond van gebruik verander"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Batterygebruik"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Geen gebruik sedert battery laas volgelaai is nie"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Nie in afgelope 24 uur gebruik nie"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"sedert battery laas volgelaai is"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Stelselprogramme"</string>
    <string name="battery_usage_uninstalled_apps" msgid="8170405012552803662">"Gedeïnstalleerde apps"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Ander"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Geskatte tyd oor"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Tot battery volgelaai is"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"Skatting kan op grond van gebruik verander"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Mediabediener"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Programoptimering"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Verbinding"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Verwyderde programme"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Batterybespaarder"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Skakel outomaties aan"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Geen skedule nie"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Gegrond op jou roetine"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Sal aanskakel op grond van jou roetine"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Gegrond op persentasie"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Batterybespaarder skakel aan as jou battery waarskynlik sal leegloop voor die volgende keer wanneer jy dit normaalweg laai"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Sal aanskakel by <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Stel \'n skedule"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Verleng batterylewe"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Skakel af wanneer dit gelaai is"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Skakel af by <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Batterybespaarder skakel af wanneer battery <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> bereik"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Skakel aan"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Gebruik Batterybespaarder"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Skakel outomaties aan"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nooit"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"met battery <xliff:g id="PERCENT">%1$s</xliff:g> vol"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Batterypersentasie"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Wys batterypersentasie op statusbalk"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Batteryvlak sedert battery laas volgelaai is"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Batteryvlak vir die afgelope 24 u."</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Programgebruik sedert battery laas volgelaai is"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Programgebruik vir die afgelope 24 u."</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Stelselgebruik sedert battery laas volgelaai is"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Stelselgebruik vir die afgelope 24 u."</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Stelselgebruik vir <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Programgebruik vir <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Stelselgebruik sedert battery laas volgelaai is tot <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Appgebruik sedert battery laas volgelaai is tot <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Total: minder as \'n min."</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Agtergrond: minder as \'n min."</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Skermtyd: minder as een min."</string>
    <string name="power_usage_time_less_than_one_minute" msgid="8407404329381010144">"Minder as ’n minuut"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Totaal: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"Agtergrond: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Skermtyd: • <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Batterygebruiksdata sal binne ’n paar uur beskikbaar wees sodra dit ten volle gelaai is"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"nou"</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_time_info_and_battery_level" msgid="6732629268310936155">"<xliff:g id="TIME_INFO">%1$s</xliff:g> <xliff:g id="BATTERY_LEVEL">%2$s</xliff:g>"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Batterygebruikgrafiek"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Grafiek van daaglikse batterygebruik"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Grafiek van uurlikse batterygebruik"</string>
    <string name="battery_level_percentage" msgid="1433178290838842146">"Batteryvlakpersentasie vanaf <xliff:g id="START_PERCENTAGE">%1$s</xliff:g> tot <xliff:g id="END_PERCENTAGE">%2$s</xliff:g>"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Batterygebruik sedert dit laas volgelaai is"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Batterygebruik vir <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Skermtyd sedert battery laas volgelaai is"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Skermtyd vir <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Bekyk volgens apps"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Bekyk volgens stelsels"</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">"Die siklustelling sal weens gehalte-inspeksies voor versending dalk nie nul wees wanneer dit vir die eerste keer gebruik word nie"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Proses-statistieke"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Bleeksiel-statistieke vir lopende prosesse"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Berginggebruik"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> van <xliff:g id="TOTALRAM">%2$s</xliff:g> gebruik oor afgelope <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> se RAM gebruik oor <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Agtergrond"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Voorgrond"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Gekas"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Android-bedryfstelsel"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Oorspronklik"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Kern"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Kaste"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"RAM-gebruik"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"RAM-gebruik (agtergrond)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Looptyd"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Prosesse"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Dienste"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Tydsduur"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Geheuebesonderhede"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 ure"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 uur"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 uur"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 dag"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Wys stelsel"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Versteek stelsel"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Wys persentasies"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Gebruik Uss"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Statistiektipe"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Agtergrond"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Voorgrond"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Gekas"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Steminvoering en -uitvoering"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Steminvoering- en -uitvoeringsinstellings"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Stemsoektog"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Android-sleutelbord"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Steminvoerinstellings"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Steminvoer"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Steminvoerdienste"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Volle aktiveerwoord en interaksie"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Eenvoudige spraak na teks"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Hierdie steminvoerdiens sal altyd-aan-stemmonitering kan verrig en stemgeaktiveerde programme namens jou kan beheer. Dit kom van die <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>-program af. Wil jy die gebruik van hierdie diens aktiveer?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Herkenninginstellings op toestel"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Herkenning op toestel"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Spraakherkenning op toestel"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Voorkeurenjin"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Enjininstellings"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Spraaktempo en -toonhoogte"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Enjin"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Stemme"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Gesproke taal"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Installeer stemme"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Gaan voort na die <xliff:g id="TTS_APP_NAME">%s</xliff:g>-program om stemme te installeer"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Maak program oop"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Kanselleer"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Stel terug"</string>
    <string name="tts_play" msgid="2945513377250757221">"Speel"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Nie veilig nie"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> is nie veilig nie"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> is nie veilig nie"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Aanpasbare konnektiwiteit"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Verleng die batterylewe en verbeter die toestel se werkverrigting deur jou netwerkverbindings outomaties te bestuur"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Aan"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Af"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Gebruik aanpasbare verbinding"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Eiebewysberging"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Installeer \'n sertifikaat"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Vee eiebewyse uit"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Verwyder alle sertifikate"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Vertroude eiebewyse"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Wys vertroude CA-sertifikate"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Gebruikereiebewyse"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Bekyk en wysig gebergde eiebewyse"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Gevorderd"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Eiebewyse is nie vir hierdie gebruiker beskikbaar nie"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Geïnstalleer vir VPN en programme"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Geïnstalleer vir wi-fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Geïnstalleer vir wi‑fi (in gebruik)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Verwyder al die inhoud?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Eiebewysberging is uitgevee."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Eiebewysberging kon nie uitgevee word nie."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Programme met gebruiktoegang"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"CA-sertifikaat"</string>
    <string name="user_certificate" msgid="6897024598058566466">"VPN-/programgebruikersertifikaat"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Wi‑Fi-sertifikaat"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Jou data sal nie privaat wees nie"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"CA-sertifikate word deur webwerwe, programme en VPN\'e vir enkripsie gebruik. Installeer net CA-sertifikate vanaf organisasies wat jy vertrou. \n\nAs jy \'n CA-sertifikaat installeer, kan die sertifikaateienaar dalk toegang kry tot jou data, soos wagwoorde of kredietkaartbesonderhede, vanaf webwerwe wat jy besoek of programme wat jy gebruik – selfs al is jou data geënkripteer."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Moenie installeer nie"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Installeer tog"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Sertifikaat is nie geïnstalleer nie"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Laat "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" toe om sertifikate op hierdie toestel te installeer?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Hierdie sertifikate sal jou verifieer deur jou toestel se unieke ID met die programme en URL\'e hieronder te deel"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Moenie toelaat nie"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Laat toe"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Wys meer"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"Sertifikaatbestuurprogram"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Geen"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Sertifikate sal jou verifieer wanneer jy die programme en URL\'e hieronder gebruik"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Deïnstalleer sertifikate"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Verwyder program"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Verwyder hierdie program?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Hierdie program sal nie sertifikate bestuur nie, maar dit sal op jou toestel bly. Enige sertifikate wat deur die program geïnstalleer is, sal gedeïnstalleer word."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}other{# URL\'e}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Noodoproepsein"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Stel gedrag wanneer \'n noodoproep gemaak word"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Rugsteun"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Rugsteun en laai terug"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Persoonlike data"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Rugsteun my data"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Rugsteun programdata, Wi-Fi-wagwoorde en ander instellings na Google-bedieners"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Rugsteunrekening"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Bestuur rugsteunrekening"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Sluit programdata in"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Outomatiese teruglaai"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Wanneer \'n program weer geïnstalleer word, herstel gerugsteunde instellings en data"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Rugsteundiens is nie aktief nie"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Geen rekening stoor tans gerugsteunde data nie"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Hou op om jou Wi-Fi-wagwoorde, boekmerke, ander instellings en programdata te rugsteun en vee al die kopieë op Google-bedieners uit?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Staak die rugsteun van toesteldata (soos Wi-Fi-wagwoorde en oproepgeskiedenis) en programdata (soos instellings en lêers wat deur programme geberg is), en vee ook alle kopieë op afgeleë bedieners uit?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Rugsteun toesteldata (soos Wi-Fi-wagwoorde en oproepgeskiedenis) en programdata (soos instellings en lêers wat deur programme geberg is) outomaties oor \'n afstand.\n\nWanneer jy outomatiese rugsteun aanskakel, word toestel- en programdata van tyd tot tyd oor \'n afstand gestoor. Programdata kan enige data wees wat \'n program gestoor het (op grond van ontwikkelaarinstellings), insluitend potensieel sensitiewe data, soos kontakte, boodskappe en foto\'s."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Toesteladministrateurinstellings"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"Toesteladministrasieprogram"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Deaktiveer hierdie toesteladministrasie-app"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Deïnstalleer program"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Deaktiveer en deïnstalleer"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Toesteladministrateurprogramme"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Geen toesteladministrateurprogramme beskikbaar nie"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Geen beskikbare vertrouensagente nie"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Aktiveer toesteladministrasie-app?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Aktiveer toesteladministrasie-app"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Toesteladministrateur"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"As hierdie toesteladministrasie-app geaktiveer word, sal die program <xliff:g id="APP_NAME">%1$s</xliff:g> toegelaat word om die volgende bewerkings uit te voer."</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Hierdie toestel sal deur <xliff:g id="APP_NAME">%1$s</xliff:g> bestuur en gemonitor word."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Hierdie administrasieprogram is aktief en laat die program <xliff:g id="APP_NAME">%1$s</xliff:g> toe om die volgende bewerkings uit te voer:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Aktiveer profielbestuurder?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Laat toesig toe?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Deur voort te gaan, sal jou gebruiker deur jou administrateur bestuur word, wat moontlik in staat sal wees om benewens jou persoonlike data ook geassosieerde data te berg.\n\nJou administrateur het die vermoë om instellings, toegang, programme en data wat met hierdie gebruiker geassosieer word, insluitend netwerkaktiwiteit en jou toestel se ligginginligting, te monitor en te bestuur."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Jou administrateur het ander opsies gedeaktiveer"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Kom meer te wete"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Kennisgewing-loglêer"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Kennisgewinggeskiedenis"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Afgelope %d uur"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Gesluimer"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Onlangs toegemaak"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# kennisgewing}other{# kennisgewings}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Oproep se luitoon en vibrasie"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Netwerkdetails"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sinkronisasie geaktiveer"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sinkronisasie gedeaktiveer"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Sinkroniseer nou"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Sinkroniseerfout."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Sinkronisasie het misluk"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sinkronisasie aktief"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sinkroniseer"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"Sinkronisering ondervind tans probleme. Dit sal binnekort terug wees."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Voeg rekening by"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Werkprofiel is nog nie beskikbaar nie"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Werkapps"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Verwyder werkprofiel"</string>
    <string name="background_data" msgid="321903213000101158">"Agtergronddata"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Programme kan te enige tyd data sinkroniseer, stuur en ontvang"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Deaktiveer agtergronddata?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"As jy die agtergronddata deaktiveer, verleng dit die batterylewe en verlaag datagebruik. Sekere programme kan dalk steeds die agtergronddataverbinding gebruik."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sinkronisering is AAN"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sinkronisering is AF"</string>
    <string name="sync_error" msgid="846923369794727644">"Sinkroniseerfout"</string>
    <string name="last_synced" msgid="1527008461298110443">"Laas gesinkroniseer <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Sinkroniseer tans..."</string>
    <string name="settings_backup" msgid="5357973563989458049">"Rugsteun instellings"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Rugsteun my instellings"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sinkroniseer nou"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Kanselleer sinkronisasie"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Tik om nou te sinkroniseer<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">"Kontakte"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Programsinkronisering-instellings"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Data en sinkronisering"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Verander wagwoord"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Rekeninginstellings"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Verwyder rekening"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Voeg \'n rekening by"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Verwyder rekening?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Hierdie verandering word nie deur jou administrateur toegelaat nie"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Kan nie handmatig sinkroniseer nie"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"Sinkronisering vir hierdie item is tans gedeaktiveer. Om hierdie instelling te verander, skakel agtergronddata en outomatiese sinkronisering tydelik aan."</string>
    <string name="delete" msgid="8330605554706263775">"Vee uit"</string>
    <string name="select_all" msgid="7898929601615536401">"Kies almal"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Datagebruik"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Mobiele data en wi‑fi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Outosinkroniseer persoonlike data"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Outo-sinkroniseer werkdata"</string>
    <string name="account_settings_menu_auto_sync_private" msgid="2315144351530596228">"Outosinkroniseer privaat data"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Verander siklus..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Dag van maand om dataverbruiksiklus terug te stel:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Geen programme het gedurende hierdie tydperk data gebruik nie."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Voorgrond"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Agtergrond"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"beperk"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Skakel mobiele data af?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Stel mobieldatalimiet"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Stel 4G-datalimiet"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Stel 2G-3G datalimiet"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Stel Wi-Fi se datalimiet"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Mobiel"</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">"Mobiel"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Geen"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Mobiele data"</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">"Swerwing"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Voorgrond:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Agtergrond:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Programinstellings"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Agtergronddata"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Aktiveer die gebruik van mobiele data op die agtergrond"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Om agtergronddata vir hierdie program te beperk, moet jy eers \'n mobieldatalimiet stel."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Beperk agtergronddata?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Hierdie funksie kan veroorsaak dat \'n program wat afhanklik is van agtergronddata, ophou werk wanneer slegs mobiele netwerke beskikbaar is.\n\nJy kan meer geskikte datagebruik-kontroles vind in die instellings wat in die program self beskikbaar is."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Agtergronddata kan net beperk word as jy \'n mobieldatalimiet gestel het."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Moet die outomatiese sinkronisering van data aangeskakel word?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Moet die outomatiese sinkronisering van data afgeskakel word?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Dit sal data- en batteryverbruik bespaar, maar jy sal elke rekening self moet sinkroniseer om onlangse inligting in te samel.  En jy sal geen kennisgewings ontvang wanneer opdaterings plaasvind nie."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Gebruiksiklus-terugsteldatum"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Datum van elke maand:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Stel"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Stel dataverbruik-waarskuwing"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Stel dataverbruiklimiet"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Beperk datagebruik"</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">"waarskuwing"</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">"limiet"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Verwyderde programme"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Verwyderde programme en gebruikers"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Netwerkgebruik"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Beperk"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Naam"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Tipe"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Bedieneradres"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"IPSec-identifiseerder"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"IPSec voorafgedeelde sleutel"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"IPSec-gebruikersertifikaat"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"IPSec CA-sertifikaat"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"IPSec-bedienersertifikaat"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Wys gevorderde opsies"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Gebruikernaam"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Wagwoord"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Stoor rekeninginligting"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(nie gebruik nie)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(moenie bediener verifieer nie)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(ontvang van bediener)"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"Die inligting wat ingevoer is, steun nie altyd-aan VPN nie"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Kanselleer"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Maak toe"</string>
    <string name="vpn_save" msgid="683868204634860888">"Stoor"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Koppel"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Vervang"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Redigeer VPN-profiel"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Vergeet"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Koppel aan <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"Ontkoppel hierdie VPN?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Ontkoppel"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Weergawe"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Vergeet VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Vervang bestaande VPN?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Stel altyd-aan VPN?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Wanneer hierdie instelling aan is, sal jy nie \'n internetverbinding hê totdat die VPN suksesvol koppel nie"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Jou bestaande VPN sal vervang word en jy sal nie \'n internetverbinding hê totdat die VPN suksesvol koppel nie"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Jy is reeds aan \'n altyd-aan VPN gekoppel. As jy aan \'n ander een koppel, sal jou bestaande VPN vervang word en sal altyd-aan-modus afgeskakel word."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Jy is reeds aan \'n VPN gekoppel. As jy aan \'n ander een koppel, sal jou bestaande VPN vervang word."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Skakel aan"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"<xliff:g id="VPN_NAME">%1$s</xliff:g> kan nie koppel nie"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Hierdie program steun nie altyd-aan VPN nie"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Voeg VPN-profiel by"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Redigeer profiel"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Vee profiel uit"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"Altydaan-VPN"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Geen VPN\'e is bygevoeg nie"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Bly te alle tye aan VPN gekoppel"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Nie gesteun deur hierdie program nie"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Altyd aan"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Nie veilig nie"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Blokkeer verbindings sonder VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Vereis VPN-verbinding?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Nie veilig nie. Dateer op na \'n IKEv2 VPN"</string>
    <string name="vpn_start_unsupported" msgid="7139925503292269904">"Kon nie ongesteunde VPN begin nie."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Kies \'n VPN-profiel om altyd aan gekoppel te bly. Netwerkverkeer sal net toegelaat word wanneer verbind aan hierdie VPN."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Geen"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"Altydaan-VPN vereis \'n IP-adres vir beide die bediener en DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Daar is geen netwerkverbinding nie. Probeer asseblief later weer."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Van VPN ontkoppel"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Geen"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"\'n Sertifikaat ontbreek. Probeer die profiel wysig."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Stelsel"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Gebruiker"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Deaktiveer"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Aktiveer"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Deïnstalleer"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Vertrou"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"Aktiveer die stelsel se CA-sertifikaat?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Deaktiveer die stelsel se CA-sertifikaat?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Verwyder die gebruiker se CA-sertifikaat permanent?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Word tans gebruik deur"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Hierdie inskrywing bevat"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 gebruikersleutel"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 gebruikersertifikaat"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 CA-sertifikaat"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d CA-sertifikate"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Eiebewysbesonderhede"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Het eiebewys verwyder: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Geen gebruikereiebewyse is geïnstalleer nie"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Speltoetser"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Speltoetser vir werk"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Voer jou huidige wagwoord vir volledige rugsteun hier in"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Voer \'n nuwe wagwoord vir volledige rugsteune hier in"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Voer weer jou nuwe wagwoord vir volledige rugsteun hier in"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Stel rugsteunwagwoord op"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Kanselleer"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Bykomende stelselopdaterings"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Netwerk kan dalk gemonitor word"</string>
    <string name="done_button" msgid="6269449526248267">"Klaar"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Vertrou of verwyder sertifikaat}other{Vertrou of verwyder sertifikate}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} het ’n sertifikaatinstansie op jou toestel geïnstalleer wat dit vir hulle moontlik kan maak om jou toestelnetwerkaktiwiteit, insluitend e-posse, programme en beveiligde webwerwe, te monitor.\n\nKontak jou admin vir meer inligting oor hierdie sertifikaat.}other{{orgName} het sertifikaatinstansies op jou toestel geïnstalleer wat dit vir hulle moontlik kan maak om jou toestelnetwerkaktiwiteit, insluitend e-posse, programme en beveiligde webwerwe, te monitor.\n\nKontak jou admin vir meer inligting oor hierdie sertifikate.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} het ’n sertifikaatinstansie vir jou werkprofiel geïnstalleer wat dit vir hulle moontlik kan maak om werknetwerkaktiwiteit, insluitend e-posse, programme en beveiligde webwerwe, te monitor.\n\nKontak jou admin vir meer inligting oor hierdie sertifikaat.}other{{orgName} het sertifikaatinstansies vir jou werkprofiel geïnstalleer wat dit vir hulle moontlik kan maak om werknetwerkaktiwiteit, insluitend e-posse, programme en beveiligde webwerwe, te monitor.\n\nKontak jou admin vir meer inligting oor hierdie sertifikate.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"\'n Derde party kan jou netwerkaktiwiteit monitor, insluitend e-posse, programme en veilige webwerwe.\n\n\'n Vertroude eiebewys wat op jou toestel geïnstalleer is, maak dit moontlik."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Gaan sertifikaat na}other{Gaan sertifikate na}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Veelvuldige gebruikers"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Gebruikers en profiele"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Voeg gebruiker of profiel by"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Beperkte profiel"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Nie opgestel nie"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Nie opgestel nie - beperkte profiel"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Nie opgestel nie – werkprofiel"</string>
    <string name="user_admin" msgid="4024553191395768119">"Admin"</string>
    <string name="user_you" msgid="3070562015202859996">"Jy (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Jy kan nie meer gebruikers byvoeg nie. Verwyder ’n gebruiker om ’n nuwe een by te voeg."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Beperkte profiele kan nie rekeninge byvoeg nie"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Vee <xliff:g id="USER_NAME">%1$s</xliff:g> van hierdie toestel af uit"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Sluitskerminstellings"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Voeg gebruikers van die sluitskerm af by"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Skakel oor na admingebruiker wanneer gedok"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Verwyder jouself?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Vee dié gebruiker uit?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Verwyder hierdie profiel?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Verwyder werkprofiel?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Alle programme en data sal uitgevee word."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Alle programme en data in hierdie profiel sal uitgevee word as jy voortgaan."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Alle programme en data sal uitgevee word."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Voeg tans nuwe gebruiker by..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Vee gebruiker uit"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Vee uit"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Alle programme en data in hierdie sessie sal uitgevee word."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Verwyder"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Gas (Jy)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Gebruikers"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Ander gebruikers"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Vee gasaktiwiteit uit"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Vee alle gasprogramme en -data uit wanneer jy gasmodus verlaat"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Vee gasaktiwiteit uit?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Programme en data van hierdie gastesessie sal nou uitgevee word, en alle toekomstige gasaktiwiteit sal uitgevee word elke keer wanneer jy gasmodus verlaat"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"vee uit, gas, aktiwiteit, verwyder, data, besoeker"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"Laat gas toe om foonoproepe te maak"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Oproepgeskiedenis sal met gasgebruiker gedeel word"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Skakel foonoproepe en SMS aan"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Maak hierdie gebruiker ’n admin"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Vee gebruiker uit"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Skakel foonoproepe en SMS aan?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Oproep- en SMS-geskiedenis sal met hierdie gebruiker gedeel word."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Verwyder adminvoorregte?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"As jy adminvoorregte vir hierdie gebruiker verwyder, kan jy of ’n ander admin hulle later teruggee."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Noodinligting"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Inligting en kontakte vir <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Maak <xliff:g id="APP_NAME">%1$s</xliff:g> oop"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Laat programme en inhoud toe"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Programme met beperkings"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Brei instellings vir program uit"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Kies programme om te installeer"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Installeer beskikbare programme"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Kontaklose betalings"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"Verstekbetalingprogram"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Hou die agterkant van jou toestel teen \'n betaalterminaal as jy met \'n betalingprogram wil betaal"</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Kom meer te wete"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Stel werkprogram as verstekbetalingprogram?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Om met \'n werkprogram te betaal:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"moet werkprofiel aangeskakel wees."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"moet jy jou werk-PIN, -patroon of -wagwoord invoer, as jy een het."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Hoe dit werk"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Betaal met jou foon in winkels"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Betalingverstek"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Nie gestel nie"</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">"Gebruik verstekbetalingprogram"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Gebruik verstekbetalingprogram"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Altyd"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Behalwe wanneer \'n ander betalingprogram oop is"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Betaal by \'n kontaklose terminaal met:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Betaling by \'n terminaal"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Stel \'n betalingprogram op. Hou dan bloot die agterkant van jou foon naby enige terminaal met die kontakloos-simbool."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Het dit"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Meer …"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Stel verstekbetalingprogram"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Dateer verstekbetalingprogram op"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Betaal by \'n kontaklose terminaal met <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Betaal by \'n kontaklose terminaal met <xliff:g id="APP_0">%1$s</xliff:g>.\n\nDit vervang <xliff:g id="APP_1">%2$s</xliff:g> as jou verstekbetalingprogram."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Stel verstek"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Dateer op"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Werk"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Beperkings"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Verwyder beperkings"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Verander PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Hulp en terugvoer"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Rekening vir die inhoud"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"Foto-ID"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Uiterste bedreigings"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Ontvang berigte vir uiterste bedreigings van lewe en eiendom"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Ernstige bedreigings"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Ontvang berigte vir ernstige bedreigings van lewe en eiendom"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"AMBER-berigte"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Ontvang bulletins oor kinderontvoerings"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Herhaal"</string>
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Draadlose noodwaarskuwings"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Netwerkoperateurs"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Toegangspuntname"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Gevorderde oproepe"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"4G-Oproepe"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Gebruik LTE-dienste om stemoproepe te verbeter (aanbeveel)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Gebruik 4G-dienste om stemoproepe te verbeter (aanbeveel)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Gebruik 5G vir stemoproepe"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Stuur kontakte na diensverskaffer toe"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Stuur jou kontakte se foonnommers om uitgebreide kenmerke te bied"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Stuur kontakte na <xliff:g id="CARRIER">%1$s</xliff:g> toe?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Stuur kontakte na jou diensverskaffer toe?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Jou kontakte se foonnommers sal van tyd tot tyd na <xliff:g id="CARRIER">%1$s</xliff:g> toe gestuur word.<xliff:g id="EMPTY_LINE">

</xliff:g>Hierdie inligting dui aan of jou kontakte sekere kenmerke, soos video-oproepe of sommige boodskapkenmerke, kan gebruik."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Jou kontakte se foonnommers sal van tyd tot tyd na jou diensverskaffer toe gestuur word.<xliff:g id="EMPTY_LINE">

</xliff:g>Hierdie inligting dui aan of jou kontakte sekere kenmerke, soos video-oproepe of sommige boodskapkenmerke, kan gebruik."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Voorkeurnetwerktipe"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (aanbeveel)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"MMS-boodskappe"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Stuur en ontvang wanneer mobiele data af is"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Skakel outomaties oor na mobiele data"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Gebruik hierdie netwerk wanneer dit meer beskikbaar is"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Werk-SIM"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Program- en inhoudtoegang"</string>
    <string name="user_rename" msgid="8735940847878484249">"HERNOEM"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Stel program-beperkings"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Beheer deur <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Hierdie program kan toegang tot jou rekeninge kry"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Hierdie program het toegang tot jou rekeninge. Word beheer deur <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Wi‑Fi en selfoon"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Laat die wysiging van Wi‑Fi en mobiele instellings toe"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Laat die wysiging van Bluetooth-saambindings en instellings toe"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Ligging"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Laat programme jou ligginginligting gebruik"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Terug"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Volgende"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Formateer op ander manier"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"SIM-kaarte"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Mobiele data is onbeskikbaar"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Tik om \'n data-SIM te kies"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Gebruik dit altyd vir oproepe"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Kies SIM vir mobiele data"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Kies \'n SIM vir SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Wissel tans data-SIM – dit kan tot \'n minuut neem …"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Gebruik <xliff:g id="NEW_SIM">%1$s</xliff:g> vir mobiele data?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"As jy na <xliff:g id="NEW_SIM">%1$s</xliff:g> toe oorskakel, sal <xliff:g id="OLD_SIM">%2$s</xliff:g> nie meer vir mobiele data gebruik word nie."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Gebruik <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Bel met"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Voer SIM-naam in"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"SIM-gleuf %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Oranje"</string>
    <string name="color_purple" msgid="6603701972079904843">"Pers"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"SIM-status"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"SIM-status (SIM-gleuf %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="6839556577405929262">"Jou SIM-kaarte het verander"</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Tik om op te stel"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Vra elke keer"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Keuse vereis"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"SIM-keuse"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Instellings"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Netwerk en internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Mobiele data, wi-fi, warmkol"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi‑fi, warmkol"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Gekoppelde toestelle"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, saambinding"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, rymodus, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, rymodus"</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, rymodus, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, rymodus"</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">"Nie beskikbaar nie want NFC is af"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Installeer eers \'n betalingprogram om dit te gebruik"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Onlangse apps, verstekapps"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Kennisgewingtoegang is nie vir programme in die werkprofiel beskikbaar nie."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Wagwoorde en rekeninge"</string>
    <string name="account_dashboard_default_summary" msgid="7976899924144356939">"Voorstelle vir aanmelding en outovul"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Verstekprogramme"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Gekloonde Apps"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Skep ’n tweede geval van ’n app sodat jy twee rekeninge op dieselfde tyd kan gebruik."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Apps wat gekloon kan word."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"<xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g> is gekloon, <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g> is beskikbaar om te kloon"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Vee alle appklone uit"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Kon nie alle appklone uitvee nie"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Skep tans …"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Gekloon"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Skep tans ’n <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>-kloon"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Het ’n <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>-kloon geskep"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Tale, gebare, tyd, rugsteun"</string>
    <string name="languages_setting_summary" msgid="2650807397396180351">"Stelseltale, apptale, streeksvoorkeure, spraak"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, wi-fi, netwerkverbinding, internet, draadloos, data, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Wi‑Fi-kennisgewing, wifi-kennisgewing"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"datagebruik"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Gebruik 24-uurformaat"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Maak oop met"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Programme"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"tydsone"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Kletskop, stelsel, opletberig, venster, dialoog, skerm, bo-op ander programme, teken"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Flitslig, Lig, Flits"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, wissel, beheer"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"sellulêr, mobiel, selfoondiensverskaffer, draadloos, data, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, oproep, bel tans"</string>
    <string name="keywords_display" msgid="874738809280751745">"skerm, raakskerm"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"dowwe skerm, raakskerm, battery, helder"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"dowwe skerm, nag, tint, nagskof, helderheid, skermkleur, kleur, kleur"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"agtergrond, personaliseer, pasmaak skerm"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"teksgrootte"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projek, saai uit, Skermweerspieëling, Skermdeling, weerspieëling, deel skerm, skermuitsending"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"spasie, skyf, hardeskyf, toestel, gebruik"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"kragverbruik, laai"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"bekyk batterygebruik, batterygebruik, kraggebruik"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"batterybespaarder, kragbespaarder, bespaarder"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"aanpasbare voorkeure, aanpasbare battery"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"spelling, woordeboek, speltoets, outokorrigeer"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"herkenner, invoer, spraak, praat, taal, handvry, handvry, herkenning, aanstootlik, woord, oudio, geskiedenis, bluetooth-kopstuk"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"gradeer, taal, verstek, praat, praat tans, tts, toeganklikheid, skermleser, blind"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"horlosie, militêr"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"stel terug, stel terug, fabriek"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"vee skoon, vee uit, stel terug, maak skoon, verwyder, fabriekterugstelling"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"drukker"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"luidsprekerbiep, luidspreker, volume, demp, maak stil, oudio, musiek, fisiese terugvoer, vibreerder, vibreer"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"moenie moenie pla nie, onderbreek, onderbreking, pouse"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"naby, ligging, geskiedenis, rapportering, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"rekening, voeg ’n rekening by, werkprofiel, voeg rekening by, verwyder, vee uit"</string>
    <string name="keywords_users" msgid="3497517660077620843">"beperking, beperk, is beperk"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"teksregstelling, korrek, klank, vibreer, outomaties, taal, gebaar, stel voor, voorstel, tema, aanstootlik, woord, tik, emosiekoon, internasionaal"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"stel terug, voorkeure, verstek"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"programme, aflaai, programme, stelsel"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"programme, toestemmings, sekuriteit"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"programme, verstek"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignoreer optimerings, dut, programbystand"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"lewendig, RGB, sRGB, kleur, natuurlik, standaard"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, resolusie, 1080 p, 1440 p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"kleur, temperatuur, D65, D73, wit, geel, blou, warm, koel"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"gly om te ontsluit, wagwoord, patroon, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"skermvasspeld"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"werkuitdaging, werk, profiel"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"werkprofiel, bestuurde profiel, verenig, vereniging, werk, profiel"</string>
    <string name="keywords_fold_lock_behavior" msgid="6278990772113341581">"wakker, slaap, moenie sluit nie, bly ontsluit wanneer gevou, vou tans, maak tans toe, vou, maak toe, skerm af"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gebare"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"Wallet"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"betaal, tik, betalings"</string>
    <string name="keywords_backup" msgid="707735920706667685">"rugsteun, rugsteun"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"gesig, ontsluit, stawing, meld aan"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"gesig, ontsluit, stawing, aanmelding, vingerafdruk, biometries"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, prl-weergawe, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"netwerk, selnetwerktoestand, dienstoestand, seinsterkte, selnetwerktipe, swerwing"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"netwerk, selnetwerktoestand, dienstoestand, seinsterkte, selnetwerktipe, swerwing, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"netwerk, selnetwerktoestand, dienstoestand, seinsterkte, selnetwerktipe, swerwing, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"netwerk, selnetwerktoestand, dienstoestand, seinsterkte, selnetwerktipe, swerwing, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"reeksnommer, hardewareweergawe"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"battery-inligting, vervaardigingdatum, siklustelling, eerste gebruik"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"android-sekuriteitregstellingvlak, basisband-weergawe, kernweergawe"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"tema, lig, donker, modus, ligsensitiwiteit, fotofobie, maak donkerder, maak donker, donkermodus, migraine"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"donker tema"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"fout"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Stemmingvertoning, sluitskermvertoning"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"sluitskermkennisgewing, kennisgewings"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"gesig"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"vingerafdruk, voeg vingerafdruk by"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"gesig, vingerafdruk, voeg vingerafdruk by"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"horlosieontsluiting, voeg horlosieontsluiting by"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"verdof skerm, raakskerm, battery, slimhelderheid, dinamiese helderheid, outohelderheid"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"slim, verdonker skerm, slaap, battery, uitteltyd, aandag, skerm, onaktiwiteit"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"kamera, slim, outodraai, outorotasie, draai, keer om, rotasie, portret, landskap, oriëntasie, vertikaal, horisontaal"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"gradeer op, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"msn, skedule, kennisgewings, blokkeer, stilte, vibreer, slaap, werk, fokus, klank, demp, dag, weeksdag, naweek, weeksaand, geleentheid"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"skerm, sluittyd, uitteltyd, sluitskerm"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"geheue, kas, data, vee uit, maak skoon, maak beskikbaar, spasie"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"gekoppel, toestel, oorfone, kopstuk, luidspreker, draadloos, bind saam, oorfoonknoppies, musiek, media"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"agtergrond, tema, rooster, pasmaak, personaliseer"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"ikoon, aksent, kleur, tuisskerm, sluitskerm, kortpad, horlosiegrootte"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"verstek, assistent"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"betaling, verstek"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"inkomende kennisgewing"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"usb-verbinding, bluetooth-verbinding, wi-fi-warmkol"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"fisiese terugvoer, vibreer, vibrasie"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"fisiese terugvoer, vibreer, skerm, sensitiwiteit"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"raakinteraksie, vibreer, foon, bel, sensitiwiteit, lui"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"raakinteraksie, vibreer, foon, bel, lui, geleidelik"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"fisiese terugvoer, vibreer, sensitiwiteit, kennisgewing"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"fisiese terugvoer, vibreer, sensitiwiteit, wekker"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"fisiese terugvoer, vibreer, sensitiwiteit, media"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"fisiese terugvoer, vibreer, vibrasie"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"batterybespaarder, vaste, volhard, kragbespaarder, battery"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"roetine, skedule, batterybespaarder, kragbespaarder, battery, outomaties, persent"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"VolTE, gevorderde oproepe, 4G-oproepe"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, gevorderde oproepe, 5g-oproepe"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"voeg taal by, voeg \'n taal by"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"teksgrootte, grootdruk, groot lettertipe, groot teks, swak sig, maak teks groter, teksvergroter, lettertipevergroting"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"altyd-aan-stemmingsaansig, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, merker, leser"</string>
    <string name="keywords_keyboard_vibration" msgid="6485149510591654697">"sleutelbord, tasbare terugvoer, vibreer,"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Volume, vibrasie, Moenie Steur Nie"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Mediavolume"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Uitsaaivolume"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Oproepvolume"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Wekkervolume"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Lui- en kennisgewingvolume"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Luivolume"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Kennisgewingvolume"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Luitoestel is stil"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Luitoestel vibreer"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"Kennisgewingvolume gedemp, kennisgewings sal vibreer"</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"<xliff:g id="VOLUME_TYPE">%1$s</xliff:g> is gedemp"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Onbeskikbaar omdat luitoon gedemp is"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Foonluitoon"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Verstekkennisgewingklank"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Klank deur program verskaf"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Verstekkennisgewingklank"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Verstekwekkerklank"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Vibreer eers en lui dan geleidelik"</string>
    <string name="spatial_audio_title" msgid="1775370104206884711">"Ruimtelike Oudio"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Belbladklanke"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Skermsluitklank"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Laaiklanke en -vibrasie"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Dokklanke"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Tik- en klik-klanke"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Wys ikoon altyd wanneer dit in vibrasiemodus is"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Dokluidspreker speel"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Alle oudio"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Net media-oudio"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Stilte"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tone"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibrasies"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Aanskakel-klanke"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Kitsopskrif"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Gee outomaties mediaopskrifte"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Draadoorfone"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"Oudio vanaf versoenbare media word meer meesleurend"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Af"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Aan/<xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Aan/<xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> en <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Jy kan ook Ruimtelike Oudio aanskakel vir Bluetooth-toestelle."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Instellings vir gekoppelde toestelle"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Geen}=1{1 skedule gestel}other{# skedules gestel}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Moenie Steur Nie"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Word net deur belangrike mense en programme in kennis gestel"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Beperk onderbrekings"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Skakel Moenie steur nie aan"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Wekkers en mediaklanke kan onderbreek"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Skedules"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Vee skedules uit"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Vee uit"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Wysig"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Skedules"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Skedule"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Skedule"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Maak foon op sekere tye stil"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Stel Moenie Steur Nie-reëls"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Skedule"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Gebruik skedule"</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">"Laat onderbrekings wat klanke maak toe"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Blokkeer visuele steurings"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Laat visuele tekens toe"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Vertoonopsies vir versteekte kennisgewings"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Wanneer Moenie Steur Nie aan is"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Geen klank van kennisgewings af nie"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Jy sal kennisgewings op jou skerm sien"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"Wanneer kennisgewings opdaag, sal jou foon nie \'n klank maak of vibreer nie."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Geen visuele elemente of klank van kennisgewings af nie"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Jy sal nie kennisgewings sien of hoor nie"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Jou foon sal nie nuwe of bestaande kennisgewings wys, vibreer of klank daarvoor maak nie. Hou in gedagte dat noodsaaklike kennisgewings vir toestelaktiwiteit en -status steeds sal verskyn.\n\nWanneer jy Moenie Steur Nie afskakel, kan jy kennisgewings kry wat jy misgeloop het deur af te swiep van die bokant van jou skerm af."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Gepasmaak"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Aktiveer gepasmaakte instelling"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Verwyder gepasmaakte instelling"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Geen klank van kennisgewings af nie"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Gedeeltelik versteek"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Geen visuele elemente of klank van kennisgewings af nie"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Gepasmaakte beperkings"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Wanneer die skerm aan is"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Wanneer die skerm af is"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Demp klank en vibrasie"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Moenie skerm aanskakel nie"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Moenie lig laat flikker nie"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Geen skerm-opspringkennisgewings nie"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Versteek statusbalk boaan skerm"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Versteek kennisgewingkolle op programikone"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Moenie wakker maak vir kennisgewings nie"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Versteek op aftrekskerm"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nooit"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Wanneer skerm af is"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Wanneer skerm aan is"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Klank en vibrasie"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Klank, vibrasie en \'n paar visuele tekens van kennisgewings"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Klank, vibrasie en visuele tekens van kennisgewings"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Kennisgewings wat vir basiese toestelaktiwiteit en -status benodig word, sal nooit versteek word nie."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Geen"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"ander opsies"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Voeg by"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Skakel aan"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Skakel nou aan"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Skakel nou af"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"Moenie Steur Nie bly aan tot <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"Moenie Steur Nie sal aan bly totdat jy dit afskakel"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"\'n Skedule (<xliff:g id="RULE_NAME">%s</xliff:g>) het Moenie Steur Nie outomaties aangeskakel"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"\'n Program <xliff:g id="APP_NAME">%s</xliff:g> het Moenie Steur Nie outomaties aangeskakel"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"Moenie Steur Nie is aan vir <xliff:g id="RULE_NAMES">%s</xliff:g> met gepasmaakte instellings."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Bekyk gepasmaakte instellings"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Net prioriteit"</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">"Aan / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Aan"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Vra elke keer"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Totdat jy dit afskakel"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 uur}other{# uur}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minuut}other{# minute}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Af}=1{Af / 1 skedule kan outomaties aanskakel}other{Af / # skedules kan outomaties aanskakel}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Wat Moenie Steur Nie kan onderbreek"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Mense"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Programme"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Wekkers en ander onderbrekings"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Skedules"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Tydsduur vir Kitsinstellings"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Algemeen"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Klank en vibrasie sal gedemp word wanneer Moenie Steur Nie aan is, met die uitsondering van die items wat jy hierbo toelaat."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Gepasmaakte instellings"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Gaan skedule na"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Het dit"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Kennisgewings"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Tydsduur"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Boodskappe, geleenthede en onthounotas"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Boodskappe, onthounotas en geleenthede sal gedemp word wanneer Moenie Steur Nie aan is, met die uitsondering van die items wat jy hierbo toelaat. Jy kan boodskapinstellings verstel om dit vir jou vriende, familielede of ander kontakte moontlik te maak om jou te bereik."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Klaar"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Instellings"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Geen visuele elemente of klank van kennisgewings af nie"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Geen klank van kennisgewings af nie"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Jy sal nie kennisgewings sien of hoor nie. Oproepe vanaf gesterde kontakte en herhaalbellers word toegelaat."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Huidige instelling)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Verander Moenie Steur Nie-kennisgewinginstellings?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Werkprofielklanke"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Gebruik persoonlike profiel se klanke"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Gebruik dieselfde klanke as jou persoonlike profiel"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Werkfoon se luitoon"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Verstekklank vir werkkennisgewing"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Verstekklank vir werkwekker"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Dieselfde as persoonlike profiel"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Gebruik persoonlike profiel se klanke?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Bevestig"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Jou werkprofiel sal dieselfde klanke as jou persoonlike profiel gebruik"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Kennisgewings"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Kennisgewinggeskiedenis, gesprekke"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Gesprek"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Bestuur"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Appkennisgewings"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Beheer kennisgewings van individuele programme af"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Algemeen"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Werkkennisgewings"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Werkprofiel"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Aanpasbare kennisgewingprioriteit"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Stel kennisgewings met laer prioriteit outomaties op Lig"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Aanpasbare kennisgewingrangskikking"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Rangskik kennisgewings outomaties volgens relevantheid"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Aanpasbare kennisgewingterugvoer"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Dui verstellings aan wat aan kennisgewings gemaak is en wys die opsie om terugvoer aan die stelsel te verskaf"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Stel kennisgewingbelangrikheid terug"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Stel belangrikheidinstellings terug wat gebruiker verander het, en laat kennisgewingassistent toe om te prioritiseer"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Voorgestelde handelinge en antwoorde"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Wys voorgestelde handelinge en antwoorde outomaties"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Wys onlangse en gesluimerde kennisgewings"</string>
    <string name="notification_history" msgid="8663811361243456201">"Kennisgewinggeskiedenis"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Gebruik kennisgewinggeskiedenis"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Kennisgewinggeskiedenis is afgeskakel"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Skakel kennisgewinggeskiedenis aan om onlangse kennisgewings en gesluimerde kennisgewings te sien"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Geen onlangse kennisgewings nie"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Jou onlangse en gesluimerde kennisgewings sal hier verskyn"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"bekyk kennisgewinginstellings"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"maak kennisgewing oop"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Laat toe dat kennisgewings gesluimer word"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Kennisgewingkol op programikoon"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Borrels"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Borrels"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Laat hierdie gesprek in \'n borrel verskyn"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Wys swewende ikoon bo-oor apps"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Skakel borrels vir toestel aan"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"As jy borrels vir hierdie program aanskakel, skakel jy ook borrels vir jou toestel aan.\n\nDit raak ander programme of gesprekke wat toegelaat word om borrels te maak."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Skakel aan"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Kanselleer"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Aan / Gesprekke kan as swerwende ikone verskyn"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Laat programme toe om borrels te wys"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Sommige gesprekke sal as swewende ikone bo-oor ander programme verskyn"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Alle gesprekke kan borrels word"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Geselekteerde gesprekke kan borrels word"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Niks kan borrels word nie"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Gesprekke"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Alle gesprekke kan borrels word, behalwe"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Skakel borrels af vir hierdie gesprek"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Skakel borrels aan vir hierdie gesprek"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Swiep regs om toe te maak, links om kieslys te wys"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Swiep links om toe te maak, regs om kieslys te wys"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Versteek stil kennisgewings in statusbalk"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Flikkerende lig"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privaatheid"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Slaan sluitskerm oor"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Gaan ná ontsluiting direk na skerm toe wat laas gebruik is. Kennisgewings sal nie op sluitskerm wys nie. Swiep van bo af na onder om hulle te sien."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Sluitskerm, sluit skerm, slaan oor, systap"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Wanneer werkprofiel gesluit is"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Wys net nuwe kennisgewings op sluitskerm"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Verwyder kennisgewings wat voorheen bekyk is outomaties van die sluitskerm"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Kennisgewings op sluitskerm"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Wys gesprekke, verstek en demp"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Wys gesprekke, verstek en stil"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Versteek stil gesprekke en kennisgewings"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Moet geen kennisgewings wys nie"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Sensitiewe kennisgewings"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Wys sensitiewe inhoud wanneer skerm gesluit is"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Sensitiewe werkprofielkennisgewings"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Wys sensitiewe werkprofielinhoud wanneer skerm gesluit is"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Wys alle kennisgewinginhoud"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Wys sensitiewe inhoud net wanneer dit ontsluit is"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Moet glad nie kennisgewings wys nie"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6326229471276829730">"Wat wil jy hê moet jou sluitskerm wys?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Sluitskerm"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Wys alle werkkennisgewinginhoud"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Versteek sensitiewe werkinhoud"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Hoe wil jy hê moet profielkennisgewings wys wanneer jou toestel gesluit is?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Profielkennisgewings"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Kennisgewings"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Programkennisgewings"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Kennisgewingkate- gorie"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Gedrag"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Gesprekke"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Gespreksafdeling"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Laat progranm toe om gespreksafdeling te gebruik"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Nie \'n gesprek nie"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Verwyder uit die gesprekafdeling"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Dit is \'n gesprek"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Voeg by die gesprekafdeling"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Geen prioriteitgesprekke nie"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# prioriteitgesprek}other{# prioriteitgesprekke}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Prioriteitgesprekke"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Wys boaan gespreksafdeling en verskyn as swewende borrels"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Boaan gespreksafdeling wys"</string>
    <string name="other_conversations" msgid="551178916855139870">"Nie-prioriteitgesprekke"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Gesprekke waaraan jy veranderinge gemaak het"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Onlangse gesprekke"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Vee onlangse gesprekke uit"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Onlangse gesprekke is verwyder"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Gesprek is verwyder"</string>
    <string name="clear" msgid="5092178335409471100">"Vee uit"</string>
    <string name="clear_conversation" msgid="5564321180363279096">"Vee uit <xliff:g id="CONVERSATION_NAME">%1$s</xliff:g>"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Prioriteit- en gewysigde gesprekke sal hier verskyn"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Nadat jy \'n gesprek as prioriteit gemerk het, of enige ander veranderinge aan gesprekke gemaak het, sal hulle hier verskyn. \n\nHoe om gesprekinstellings te verander: \nSwiep van die bokant van die skerm af om die kennisgewingskerm oop te maak, en raak en hou dan \'n gesprek."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimeer"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Spring op skerm"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Stil"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Verstek"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Laat onderbrekings toe"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Laat die program \'n geluid maak, vibreer en/of kennisgewings op die skerm wys"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioriteit"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Wys boaan die gespreksafdeling, verskyn as \'n swewende borrel, wys profielfoto op sluitskerm"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> steun nie die meeste gesprekskenmerke nie. Jy kan nie \'n gesprek as prioriteit stel nie, en gesprekke sal nie as swewende borrels verskyn nie."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Vou kennisgewings in na een lyn op die aftrekskerm"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Geen klank of vibrasie nie"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"Geen klank of vibrasie nie en verskyn laer in gespreksafdeling"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Kan lui of vibreer op grond van toestelinstellings"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Wys kennisgewings as \'n banier boaan die skerm wanneer die toestel ontsluit is"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Alle \"<xliff:g id="APP_NAME">%1$s</xliff:g>\"-kennisgewings"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Alle <xliff:g id="APP_NAME">%1$s</xliff:g>-kennisgewings"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Omtrent # kennisgewing per dag}other{Omtrent # kennisgewings per dag}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Omtrent # kennisgewing per week}other{Omtrent # kennisgewings per week}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nooit"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Toestel- en appkennisgewings"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Beheer watter apps en toestelle kennisgewings kan lees"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"Toegang tot werkprofielkennisgewings is geblokkeer"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Verbeterde kennisgewings"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Kry voorgestelde handelinge, antwoorde en meer"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Geen"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Geen geïnstalleerde programme het kennisgewingtoegang versoek nie."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Laat kennisgewingtoegang toe"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Verbeterde kennisgewings het Android se aanpasbare kennisgewings in Android 12 vervang. Hierdie kenmerk wys voorgestelde handelinge en antwoorde en organiseer jou kennisgewings. \n\nVerbeterde kennisgewings het toegang tot kennisgewinginhoud, insluitend persoonlike inligting soos kontakname en boodskappe. Hierdie kenmerk kan ook kennisgewings toemaak of daarop antwoord, soos om foonoproepe te beantwoord en Moenie Steur Nie te beheer."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Laat kennisgewingtoegang vir <xliff:g id="SERVICE">%1$s</xliff:g> toe?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"Die <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>-app sal alle kennisgewings kan lees, insluitend persoonlike inligting soos kontakname, foto’s en die teks van boodskappe wat jy ontvang. Hierdie app sal ook kennisgewings kan laat sluimer of toemaak of knoppies in kennisgewings kan gebruik, insluitend om foonoproepe te beantwoord. \n\nDit sal die app ook in staat stel om Moenie Steur Nie aan of af te skakel en verwante instellings te verander."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"Die <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>-app sal die volgende kan doen:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Lees jou kennisgewings"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Dit kan jou kennisgewings lees, insluitend persoonlike inligting soos kontakte, boodskappe en foto\'s."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Antwoord op boodskappe"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Dit kan antwoord op boodskappe en handelingknoppies in kennisgewings gebruik, insluitend om kennisgewings te sluimer of toe te maak en oproepe te beantwoord."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Verander instellings"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Dit kan Moenie Steur Nie aan- of afskakel en verwante instellings verander."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"As jy kennisgewingtoegang vir <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> afskakel, kan Moenie Steur Nie-toegang dalk ook afgeskakel word."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Skakel af"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Kanselleer"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Intyds"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Voortgesette kommunikasie vanaf programme wat gebruik word, navigasie, foonoproepe en meer"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Gesprekke"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS\'e, teksboodskappe en ander kommunikasie"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Kennisgewings"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Kan lui of vibreer op grond van instellings"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Stil"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Kennisgewings wat nooit \'n geluid maak of vibreer nie"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Toegelaat"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Nie toegelaat nie"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Sien alle programme"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Verander instellings vir elke program wat kennisgewings stuur"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Programme wat op toestel gewys word"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Hierdie program steun nie verbeterde instellings nie"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Meer instellings"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Meer instellings is binne hierdie app beskikbaar"</string>
    <string name="notification_polite_title" msgid="6121016426991791557">"Kennisgewingbedaring"</string>
    <string name="notification_polite_all_apps" msgid="1118651561594250059">"Pas bedaring toe op alle kennisgewings"</string>
    <string name="notification_polite_all_apps_summary" msgid="540268373207498126">"Verminder die aantal kennisgewings geleidelik wanneer jy baie agtereenvolgende kennisgewings van dieselfde app af kry"</string>
    <string name="notification_polite_conversations" msgid="8197695136727245741">"Pas bedaring toe op gesprekke"</string>
    <string name="notification_polite_conversations_summary" msgid="2677141765664359994">"Verminder die aantal kennisgewings geleidelik wanneer jy in ’n kort tydperk baie boodskappe van dieselfde klets af kry"</string>
    <string name="notification_polite_disabled" msgid="1378078021594282842">"Moenie kennisgewingbedaring gebruik nie"</string>
    <string name="notification_polite_disabled_summary" msgid="1145341260283746936">"Moet nooit die aantal kennisgewings verminder nie, ongeag hoeveel agtereenvolgende kennisgewings daar van dieselfde app af kom"</string>
    <string name="notification_polite_vibrate_unlocked" msgid="6142573851761357903">"Vibreer wanneer dit ontsluit is"</string>
    <string name="notification_polite_vibrate_unlocked_summary" msgid="1678472892282874459">"Vibreer slegs wanneer skerm ontsluit is"</string>
    <string name="notification_polite_work" msgid="8823596456640216391">"Pas toe op werkprofiele"</string>
    <string name="notification_polite_work_summary" msgid="8260947839104352075">"Pas jou persoonlike profiel se kennisgewingbedaringinstellings op jou werkprofiel toe"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"VR-helperdienste"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Geen geïnstalleerde programme het versoek om as VR-helperdienste te werk nie."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Gee <xliff:g id="SERVICE">%1$s</xliff:g> toegang tot VR-diens?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> sal kan werk wanneer jy programme in virtuelerealiteit-modus gebruik."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Wanneer \'n toestel in VR is"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Verminder wasigheid (aanbeveel)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Verminder flikker"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Beeld-in-beeld"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Geen geïnstalleerde program steun beeld-in-beeld nie"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"beeld-in-beeld-prent in"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Beeld-in-beeld"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Laat beeld-in-beeld toe"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Laat toe dat hierdie program \'n beeld-in-beeld-venster skep terwyl die program oop is of nadat jy dit verlaat het (byvoorbeeld, om voort te gaan om \'n video te kyk). Hierdie venster wys bo-oor ander programme wat jy gebruik."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Gekoppelde werk- en persoonlike programme"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Gekoppel"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Nie gekoppel nie"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Geen gekoppelde programme nie"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"kruisprofiel gekoppelde program programme werk en persoonlik"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Gekoppel"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Koppel hierdie programme"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Gekoppelde programme deel toestemmings en het toegang tot mekaar se data."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Jy moet programme net koppel as jy vertrou dat hulle nie persoonlike data met jou IT-admin sal deel nie."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Jy kan programme enige tyd in jou toestel se privaatheidinstellings ontkoppel."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Vertrou jy werks-<xliff:g id="NAME">%1$s</xliff:g> met jou persoonlike data?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Jy moet programme net koppel as jy vertrou dat hulle nie persoonlike data met jou IT-admin sal deel nie."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Programdata"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Hierdie program kan toegang tot data in jou persoonlike <xliff:g id="NAME">%1$s</xliff:g>-program kry."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Toestemmings"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Hierdie program kan jou persoonlike <xliff:g id="NAME">%1$s</xliff:g>-program se toestemmings gebruik, soos toegang tot ligging, berging of kontakte."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Geen programme is gekoppel nie"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# app is gekoppel}other{# apps is gekoppel}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Om hierdie programme te skakel, moet jy <xliff:g id="NAME">%1$s</xliff:g> in jou werkprofiel installeer"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Om hierdie programme te skakel, moet jy <xliff:g id="NAME">%1$s</xliff:g> in jou persoonlike profiel installeer"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Tik om die program te kry"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Toegang tot Moenie Steur Nie"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Laat Moenie Steur Nie toe"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Geen geïnstalleerde programme het toegang tot Moenie Steur Nie versoek nie"</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Jy het nie kennisgewings van hierdie app af toegelaat nie"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Android keer tans op jou versoek dat hierdie kategorie kennisgewings op hierdie toestel verskyn"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Android keer tans op jou versoek dat hierdie groep kennisgewings op hierdie toestel verskyn"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Hierdie app stuur nie kennisgewings nie"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Kategorieë"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Ander"</string>
    <string name="no_channels" msgid="4716199078612071915">"Hierdie program het nie enige kennisgewings geplaas nie"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Bykomende instellings in die program"</string>
    <string name="show_unused_channels" msgid="2754356124204058828">"Vertoon ongebruikte kanale"</string>
    <string name="hide_unused_channels" msgid="9049958190570733200">"Versteek ongebruikte kanale"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# kategorie is uitgevee}other{# kategorieë is uitgevee}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Blokkeer almal"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Moet nooit hierdie kennisgewings wys nie"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Wys kennisgewings"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Moet nooit kennisgewings in die skadu of op randtoestelle wys nie"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Laat volskermkennisgewings toe"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Laat toe dat kennisgewings die volle skerm beslaan wanneer die toestel gesluit is"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Laat kennisgewingkol toe"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Wys kennisgewingkol"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Ignoreer Moenie Steur Nie"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Laat hierdie kennisgewings aanhou om te onderbreek wanneer Moenie Steur Nie aan is"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Sluitskerm"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Klaar"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Flikkerende lig"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibrasie"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Klank"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioriteit"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Skedule se naam"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Voer skedulenaam in"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"Skedulenaam word reeds gebruik"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Voeg nog by"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Voeg geleentheidskedule by"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Voeg tydskedule by"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Kies soort skedule"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Vee \"<xliff:g id="RULE">%1$s</xliff:g>\"-reël uit?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Vee uit"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Hierdie instellings kan nie nou onmiddellik verander word nie. \'n Program (<xliff:g id="APP_NAME">%1$s</xliff:g>) het Moenie Steur Nie outomaties aangeskakel met gepasmaakte gedrag."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Hierdie instellings kan nie nou onmiddellik verander word nie. \'n Program het Moenie Steur Nie outomaties aangeskakel met gepasmaakte gedrag."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Hierdie instellings kan nie nou onmiddellik verander word nie. Moenie Steur Nie is self aangeskakel met gepasmaakte gedrag."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Tyd"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Geleentheid"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Tydens geleenthede vir"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Enige kalender"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Wanneer die antwoord is"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Ja, Miskien of Nie geantwoord nie"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Ja of Miskien"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Ja"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Reël is nie gevind nie."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Aan / <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">"Dae"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Geen"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"Wekker kan eindtyd oorskry"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Skedule skakel af wanneer wekker lui"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Moenie Steur Nie-gedrag"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Gebruik verstekinstellings"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Skep gepasmaakte instellings vir dié skedule"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Vir \"<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">"Gesprekke"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Alle gesprekke"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Prioriteitgesprekke"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"prioriteitgesprekke"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Geen"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Geen}=1{1 gesprek}other{# gesprekke}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Wie kan onderbreek"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Selfs al kan boodskap- of oproepprogramme jou nie in kennis stel nie, kan mense wat jy hier kies jou steeds deur daardie programme bereik"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Oproepe"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Oproepe"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"oproepe"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Oproepe wat kan onderbreek"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Kyk of jou toestel gestel is om te lui om seker te wees dat toegelate oproepe \'n klank maak"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Inkomende oproepe word vir \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\" geblokkeer. Jy kan instellings verstel om dit vir jou vriende, familielede of ander kontakte moontlik te maak om jou te bereik."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Gesterde kontakte"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Geen}=1{{contact_1}}=2{{contact_1} en {contact_2}}=3{{contact_1}, {contact_2} en {contact_3}}other{{contact_1}, {contact_2} en # ander mense}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Geen naam nie)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Boodskappe"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"boodskappe"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Boodskappe"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Boodskappe wat kan onderbreek"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Kyk of jou toestel gestel is om te lui om seker te wees dat toegelate boodskappe \'n klank maak"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Inkomende boodskappe word vir \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\" geblokkeer. Jy kan instellings verstel om dit vir jou vriende, familielede of ander kontakte moontlik te maak om jou te bereik."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Alle boodskappe kan jou bereik"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Alle oproepe kan jou bereik"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Geen}=1{1 kontak}other{# kontakte}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Enigiemand"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Kontakte"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Gesterde kontakte"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Geen"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Geen"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Wekkers"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Van aftellers, wekkers, sekuriteitstelsels en ander programme af"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"wekkers"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Wekkers"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Mediaklanke"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Klanke van video\'s, speletjies en ander media af"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"media"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Media"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Raakklanke"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Klanke van die sleutelbord en ander knoppies"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"raakklanke"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Raakklanke"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Onthounotas"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Van take en onthounotas af"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"onthounotas"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Onthounotas"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Kalendergeleenthede"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Van komende kalendergeleenthede af"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"geleenthede"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Geleenthede"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Laat programme toe om te ignoreer"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Programme wat kan onderbreek"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Kies meer programme"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Geen programme gekies nie"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Geen programme kan onderbreek nie"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Voeg programme by"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Alle kennisgewings"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Sommige kennisgewings"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Geselekteerde mense kan jou steeds bereik, selfs al laat jy nie programme toe om te onderbreek nie"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Geen programme kan onderbreek nie}=1{{app_1} kan onderbreek}=2{{app_1} en {app_2} kan onderbreek}=3{{app_1}, {app_2} en {app_3} kan onderbreek}other{{app_1}, {app_2} en nog # kan onderbreek}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Programme"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Kennisgewings wat kan onderbreek"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Laat alle kennisgewings toe"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Niks kan onderbreek nie}=1{{sound_category_1} kan onderbreek}=2{{sound_category_1} en {sound_category_2} kan onderbreek}=3{{sound_category_1}, {sound_category_2} en {sound_category_3} kan onderbreek}other{{sound_category_1}, {sound_category_2} en nog # kan onderbreek}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Niks kan onderbreek nie"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Niemand kan onderbreek nie"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Sekere mense kan onderbreek"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Alle mense kan onderbreek"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Herhaalbellers"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Laat herhaalbellers toe"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"enigiemand"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"kontakte"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"gesterde kontakte"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"herhaalbellers"</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> en <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"As dieselfde persoon binne \'n tydperk van <xliff:g id="MINUTES">%d</xliff:g> minute \'n tweede keer bel"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Begintyd"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Eindtyd"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> volgende dag"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Verander onbepaald na net wekkers"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Verandering aan wekkers vir slegs een minuut tot {time}}other{Verandering aan wekkers vir slegs # minute (tot {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Verandering aan wekkers vir slegs een uur tot {time}}other{Verandering aan wekkers vir slegs # uur tot {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Verander tot <xliff:g id="FORMATTEDTIME">%1$s</xliff:g> na net wekkers"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Verander na onderbreek altyd"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Waarskuwing"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Maak toe"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Stuur terugvoer oor hierdie toestel"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Voer admin-PIN in"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Aan"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Af"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Aan"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Af"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Aan"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Af"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Programvasspeld"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Deur programme vas te speld, kan jy die huidige program in sig hou totdat jy dit ontspeld. Hierdie kenmerk kan byvoorbeeld gebruik word om dit vir \'n vertroude vriend moontlik te maak om \'n spesifieke speletjie te speel."</string>
    <string name="screen_pinning_description" msgid="5822120806426139396">"Wanneer ’n app vasgespeld is, kan die vasgespelde app ander apps oopmaak en kan daar dalk toegang tot persoonlike data verkry word. \n\nOm appvasspeld te gebruik: 	\n{0,number,integer}. Skakel appvasspeld aan 	\n{1,number,integer}. Maak Oorsig oop 	\n{2,number,integer}. Tik op die appikoon boaan die skerm en tik dan op Speld Vas"</string>
    <string name="screen_pinning_guest_user_description" msgid="2307270321127139579">"Wanneer ’n app vasgespeld is, kan die vasgespelde app ander apps oopmaak en kan daar dalk toegang tot persoonlike data verkry word. \n\nProbeer eerder ’n gasgebruiker gebruik as jy jou toestel veilig met iemand wil deel. \n\nOm appvasspeld te gebruik: 	\n{0,number,integer}. Skakel appvasspeld aan 	\n{1,number,integer}. Maak Oorsig oop 	\n{2,number,integer}. Tik op die appikoon boaan die skerm en tik dan op Speld Vas"</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Wanneer program vasgespeld is: \n\n•	 Kan daar dalk toegang tot persoonlike data verkry word (soos kontakte en e-posinhoud) \n\n•	 Vasgespelde program kan ander programme oopmaak \n\nGebruik net programvasspeld met mense wat jy vertrou."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Vra ontsluitpatroon voordat jy ontspeld"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Vra PIN voordat jy ontspeld"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Vra wagwoord voordat jy ontspeld"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Sluit toestel wanneer jy ontspeld"</string>
    <string name="confirm_sim_deletion_title" msgid="7262127071183428893">"Bevestig dat jy jou e-SIM wil uitvee"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Verifieer dat dit jy is voordat jy ’n e-SIM uitvee"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Gevorderde geheuebeskermingbeta"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Gevorderde geheuebeskerming"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Hierdie betakenmerk help jou om jou toestel te beskerm teen foute wat jou veiligheid kan bedreig."</string>
    <string name="memtag_on" msgid="824938319141503923">"Aan"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Af"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Aan ná herbegin"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Af ná herbegin"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Tans onbeskikbaar vir jou toestel"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Altyd aan vir jou toestel"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Jy sal jou toestel moet herbegin om gevorderde geheuebeskerming aan of af te skakel. Wanneer dit aan is, sal jy dalk opmerk dat jou toestel stadiger werk."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Herbegin toestel?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Jy sal jou toestel moet herbegin om gevorderde geheuebeskerming aan te skakel."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Jy sal jou toestel moet herbegin om gevorderde geheuebeskerming af te skakel."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Herbegin"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Nie nou nie"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Kom meer te wete oor gevorderde geheuebeskerming."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"Hierdie werkprofiel word bestuur deur:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Bestuur deur <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Maak by verstek oop"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Maak gesteunde skakels oop"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Laat toe dat webskakels in hierdie program oopmaak"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Skakels om in hierdie program oop te maak"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Gesteunde skakels"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Ander verstekvoorkeure"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Voeg skakel by"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"\'n Program kan skakels verifieer om outomaties in die program oop te maak."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# geverifieerde skakel}other{# geverifieerde skakels}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Hierdie skakel is geverifieer en maak outomaties in hierdie app oop.}other{Hierdie skakels is geverifieer en maak outomaties in hierdie app oop.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"OK"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Wys lys verifikasieskakels"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Soek tans vir ander gesteunde skakels …"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Kanselleer"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# gesteunde skakel}other{# gesteunde skakels}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Voeg by"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Maak oop in <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> gebruik in <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"interne berging"</string>
    <string name="storage_type_external" msgid="125078274000280821">"eksterne berging"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> gebruik sedert <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Berging gebruik"</string>
    <string name="change" msgid="273206077375322595">"Verander"</string>
    <string name="change_storage" msgid="8773820275624113401">"Verander berging"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Kennisgewings"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Aan"</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">"Af"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# kategorie is afgeskakel}other{# kategorieë is afgeskakel}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# bykomende toestemming}other{# bykomende toestemmings}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Geen toestemmings is verleen nie"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Geen toestemmings is versoek nie"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Beheer apptoegang tot jou data"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Privaatheidkontroleskerm"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Wys watter programme onlangs toestemmings gebruik het"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Ongebruikte programme"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# ongebruikte app}other{# ongebruikte apps}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Ongebruikte programinstellings"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Onderbreek programaktiwiteit as ongebruik"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Verwyder toestemmings, vee tydelike lêers uit, en stop kennisgewings"</string>
    <string name="unused_apps_switch_v2" msgid="7464060328451454469">"Bestuur app indien ongebruik"</string>
    <string name="unused_apps_switch_summary_v2" msgid="3182898279622036805">"Verwyder toestemmings, vee tydelike lêers uit, stop kennisgewings en argiveer die app"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Alle apps"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Geïnstalleerde programme"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Kitsprogramme"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Afgeskakel"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Gevorderd"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Toestemmingbestuurder"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Datadelingopdaterings vir ligging"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Gaan apps na wat die manier waarop hulle jou liggingdata kan deel, verander het"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Tik om wakker te maak"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Dubbeltik enige plek op die skerm om die toestel wakker te maak"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Oopmaak van skakels"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Moenie gesteunde skakels oopmaak nie"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Maak <xliff:g id="DOMAIN">%s</xliff:g> oop"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Maak <xliff:g id="DOMAIN">%s</xliff:g> en ander URL\'e oop"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Laat program toe om gesteunde skakels oop te maak"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Vra elke keer"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Moenie program toelaat om skakels oop te maak nie"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{App beweer dat dit # skakel hanteer}other{App beweer dat dit # skakels hanteer}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"Program beweer dat dit die volgende skakels hanteer:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Bystand en steminvoer"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"Digitaleassistentprogram"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"Verstekdigitaleassistentprogram"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Stem in"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Blaaierprogram"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Foonprogram"</string>
    <string name="system_app" msgid="1863291702508355041">"(Stelsel)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Programberging"</string>
    <string name="usage_access" msgid="5487993885373893282">"Gebruiktoegang"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Laat gebruiktoegang toe"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Skermtyd"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"Gebruiktoegang laat \'n program toe om na te spoor watter ander programme jy gebruik en hoe gereeld, sowel as jou diensverskaffer, taalinstellings en ander besonderhede."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Geheue"</string>
    <string name="always_running" msgid="9012705720688200252">"Altyd aktief (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Soms aktief (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Selde aktief (<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">"Batteryoptimering"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Nie geoptimeer nie"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Nie geoptimeer nie"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimeer batterygebruik"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Batteryoptimering is nie beskikbaar nie"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Laat program altyd in die agtergrond loop?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"As jy <xliff:g id="APP_NAME">%1$s</xliff:g> toelaat om altyd op die agtergrond te loop, kan dit die batterylewe verkort. \n\nJy kan dit later in Instellings &gt; Programme verander."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> gebruik sedert battery laas volgelaai is"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> gebruik in afgelope 24 uur"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Geen batterygebruik sedert dit laas volgelaai is nie"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Deel foutverslag?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Jou IT-administrateur het \'n foutverslag versoek om met die foutsporing van hierdie toestel te help. Programme en data sal dalk gedeel word."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Jou IT-administrateur het \'n foutverslag versoek om met die foutsporing van hierdie toestel te help. Programme en data sal dalk gedeel word en jou toestel sal dalk tydelik stadiger wees."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Hierdie foutverslag word tans met jou IT-administrateur gedeel. Kontak jou IT-administrateur vir meer besonderhede."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Deel"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Weier"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Geen dataoordrag nie"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Laai gekoppelde toestel"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Lêeroordrag"</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">"Skakel video\'s om na AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Video\'s sal op meer mediaspelers speel, maar die gehalte kan swakker wees"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"USB-verbinding"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Gebruik USB vir"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Verstek-USB-opstelling"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Wanneer \'n ander toestel gekoppel is en jou foon is ontsluit, sal hierdie instellings toegepas word. Koppel net aan vertroude toestelle."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Kragopsies"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Lêeroordragopsies"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"USB-voorkeure"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB word beheer deur"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Gekoppelde toestel"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Hierdie toestel"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Skakel tans oor …"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Kon nie oorskakel nie"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Laai tans hierdie toestel"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Laai tans gekoppelde toestel"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Lêeroordrag"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"USB-verbinding"</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">"Lêeroordrag en verskaf krag"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"USB-verbinding en verskaf krag"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP en verskaf krag"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI en verskaf krag"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Webkamera en voorsien krag"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Agtergrondkontrolering"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Gebruik teks van die skerm af"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Gee die bystandprogram toegang tot die skerminhoud as teks"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Gebruik skermkiekie"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Gee die bystandprogram toegang tot \'n prent van die skerm"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Laat skerm flikker"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Laat rande van skerm flikker wanneer bystandprogram die skerm- of skermkiekieteks inspekteer"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Bystandprogramme kan jou help op grond van inligting vanaf die skerm waarna jy kyk. Sommige programme steun sowel lanseerder- as steminvoerdienste om vir jou geïntegreerde bystand te gee."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Gemiddelde geheuegebruik"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Maksimum geheuegebruik"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Geheuegebruik"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Programgebruik"</string>
    <string name="memory_details" msgid="6133226869214421347">"Besonderhede"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Gemiddeld <xliff:g id="SIZE">%1$s</xliff:g> se geheue gebruik in die afgelope 3 uur"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Geen geheue gebruik in die afgelope 3 uur nie"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Sorteer volgens gemiddelde gebruik"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Sorteer volgens maksimum gebruik"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Werkverrigting"</string>
    <string name="total_memory" msgid="5244174393008910567">"Totale geheue"</string>
    <string name="average_used" msgid="690235917394070169">"Gemiddeld gebruik (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Beskikbaar"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Geheue wat deur programme gebruik word"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 app het geheue gebruik in die afgelope {time}}other{# apps het geheue gebruik in die afgelope {time}}}"</string>
    <string name="force_enable_pss_profiling_title" msgid="2253816522775341523">"Aktiveer geheuegebruikprofielbepaling"</string>
    <string name="force_enable_pss_profiling_summary" msgid="7714294324548399136">"Geheuegebruikprofielbepaling vereis bykomende stelselhulpbronne."</string>
    <string name="pss_profiling_disabled" msgid="1967278421143514850">"Geheueprofielbepaling is gedeaktiveer"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Frekwensie"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Maksimum gebruik"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Geen data is gebruik nie"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Laat toegang tot Moenie Steur Nie vir <xliff:g id="APP">%1$s</xliff:g> toe?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"Die program sal Moenie Steur Nie aan of af kan skakel en veranderinge aan verwante instellings kan aanbring."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Moet aangeskakel bly want kennisgewingtoegang is aan"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Herroep <xliff:g id="APP">%1$s</xliff:g> se toegang tot Moenie Steur Nie?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Alle Moenie Steur Nie-reëls wat deur hierdie program geskep is, sal verwyder word."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Moenie optimaliseer nie"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimaliseer"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Sal jou battery dalk vinniger laat afloop. Program sal nie meer beperk word om agtergrondbattery te gebruik nie."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Aanbeveel vir beter batterylewe"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Geen"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Jou administrateur kan steeds datagebruik vir programme in jou werkprofiel naspoor selfs al skakel jy gebruikstoegang vir hierdie program af"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Wys bo-oor ander programme"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Wys bo-oor ander programme"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Laat toe dat dit bo-oor ander programme wys"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Laat hierdie program toe om te wys bo-oor ander programme wat jy gebruik. Hierdie program sal kan sien waarop jy tik of verander wat op die skerm gewys word."</string>
    <string name="media_routing_control_title" msgid="6402800638960066807">"Verander media-uitset"</string>
    <string name="allow_media_routing_control" msgid="4907036637509360616">"Laat app toe om media-uitset te ruil"</string>
    <string name="allow_media_routing_description" msgid="8343709701298051207">"Laat hierdie app toe om te kies watter gekoppelde toestel oudio of video van ander apps af speel. Indien toegelaat, kan hierdie app toegang kry tot ’n lys beskikbare toestelle soos oorfone en luidsprekers, en kies watter uitsettoestel gebruik word om oudio of video te stroom of uit te saai."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Toegang tot alle lêers"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Laat toegang toe om alle lêers te bestuur"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Laat hierdie program toe om alle lêers op hierdie toestel of enige gekoppelde bergingvolumes te lees, te wysig en uit te vee. Indien toestemming verleen word, kan die program sonder jou uitdruklike medewete by lêers ingaan."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Kan by alle lêers ingaan"</string>
    <string name="voice_activation_apps_title" msgid="7130045161611529825">"Apps met stemaktivering"</string>
    <string name="permit_voice_activation_apps" msgid="9152780172988949319">"Laat stemaktivering toe"</string>
    <string name="allow_voice_activation_apps_description" msgid="6369745626995060656">"Stemaktivering gebruik stemopdrag om goedgekeurde apps handvry aan te skakel. Ingeboude aanpasbare waarneming verseker dat data privaat bly net vir jou.\n\n"<a href="">"Meer oor beskermde aanpasbare waarneming"</a></string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Volskermkennisgewings"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Laat volskermkennisgewings van hierdie app af toe"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Laat hierdie app toe om kennisgewings te wys wat die volle skerm beslaan wanneer die toestel gesluit is. Apps kan dit gebruik om wekkers, inkomende oproepe en ander dringende kennisgewings uit te lig."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Mediabestuurprogramme"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Laat program toe om media te bestuur"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Indien dit toegelaat word, kan hierdie program medialêers wat met ander programme geskep is, wysig of uitvee sonder om jou te vra. Program moet toegang tot lêers en media hê."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Media, lêer, bestuur, bestuurder, wysig, redigeerder, program, app"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"vr virtuele realiteit luisteraar stereo helper diens"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Wys bo-oor ander programme"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Programme met toestemming"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Toegelaat"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Nie toegelaat nie"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"installeer programme uit onbekende bronne"</string>
    <string name="write_settings" msgid="6864794401614425894">"Verander stelselinstellings"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"skryf wysig stelselinstellings"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Kan ander programme installeer"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Kan stelselinstellings verander"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Kan stelselinstellings verander"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Verander stelselinstellings"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Laat toe dat stelselinstellings verander word"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Hierdie toestemming laat \'n program toe om stelselinstellings te verander."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Laat van hierdie bron af toe"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Dubbeldraai vir kamera"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Maak die kameraprogram oop deur jou pols twee keer vinnig te draai"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Vertoongrootte"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Maak alles groter of kleiner"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"skermdigtheid, skermzoem, skaal, skaalverandering"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Voorskou"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Maak kleiner"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Maak groter"</string>
    <string name="disconnected" msgid="3469373726996129247">"Nie gekoppel nie"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Nie gekoppel nie"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> programme is geïnstalleer"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> gebruik – <xliff:g id="FREE_SPACE">%2$s</xliff:g> beskikbaar"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Donkertema, lettergrootte, helderheid"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Gemiddeld <xliff:g id="USED_MEMORY">%1$s</xliff:g> van <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> berging gebruik"</string>
    <string name="users_summary" msgid="8473589474976307510">"Aangemeld as <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Opgedateer na Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Opdatering is beskikbaar"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Geblokkeer deur werkbeleid"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Kan nie volume verander nie"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Kan nie oproepe maak nie"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Kan nie SMS\'e stuur nie"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Kan nie kamera gebruik nie"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Kan nie skermskote neem nie"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Kan nie hierdie program oopmaak nie"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Geblokkeer deur jou kredietverskaffer"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Ouer word benodig"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Gee die foon vir jou ouer om dit te begin opstel"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Gee die foon vir jou ouer om toe te laat dat hierdie instelling verander word."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Kontak jou IT-admin vir meer inligting"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Meer besonderhede"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Jou administrateur kan programme en data wat met jou werkprofiel geassosieer word, insluitend instellings, toestemmings, korporatiewe toegang, netwerkaktiwiteit en die toestel se ligginginligting, monitor en bestuur."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Jou administrateur kan programme en data wat met hierdie gebruiker geassosieer word, insluitend instellings, toestemmings, korporatiewe toegang, netwerkaktiwiteit en die toestel se ligginginligting, monitor en bestuur."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"Jou administrateur kan programme en data wat met hierdie toestel geassosieer word, insluitend instellings, toestemmings, korporatiewe toegang, netwerkaktiwiteit en die toestel se ligginginligting, monitor en bestuur."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Jou toesteladministrateur kan dalk toegang kry tot data wat met hierdie toestel geassosieer word, programme bestuur, en hierdie toestel se instellings verander."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Skakel af"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Skakel aan"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Wys"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Versteek"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"Warmkol is aktief"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Vliegtuigmodus is aan"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Netwerke is nie beskikbaar nie"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"Moenie Steur Nie is aan"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Foon is gedemp"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Met uitsonderings"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Batterybespaarder is aan"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Kenmerke is beperk"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Mobiele data is af"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet is net oor Wi‑Fi beskikbaar"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Databespaarder"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Kenmerke is beperk"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Werkprofiel is af"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Vir programme en kennisgewings"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Skakel klank aan"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Luitoestel is gedemp"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Vir oproepe en kennisgewings"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Net vibrasie"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Vir oproepe en kennisgewings"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Stel Aandbeligting-skedule"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Tint outomaties skerm elke nag"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"Aandbeligting is aan"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Skerm het geelbruin tint"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Grysskaal"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Vertoon net in grys"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Vou in"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Koel kleurtemperatuur"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Gebruik koeler skermkleure"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Skakel skerm af om kleur toe te pas"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Kameralasersensor"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Outomatiese stelselopdaterings"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Pas opdaterings toe wanneer toestel herbegin"</string>
    <string name="usage" msgid="287782903846013936">"Gebruik"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Mobieledatagebruik"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Appdatagebruik"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Wi-Fi-datagebruik"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Niediensverskafferdatagebruik"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Ethernet-datagebruik"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> mobiele data"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> Wi-Fi-data"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> ethernetdata"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Datawaarskuwing en -limiet"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Mobieledatagebruiksiklus"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"<xliff:g id="ID_1">^1</xliff:g>-datawaarskuwing"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"<xliff:g id="ID_1">^1</xliff:g>-datalimiet"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"<xliff:g id="ID_1">^1</xliff:g>-datawaarskuwing / <xliff:g id="ID_2">^2</xliff:g>-datalimiet"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Sluit data uit wat deur diensverskaffernetwerke gebruik word"</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> gebruik"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Stel datawaarskuwing"</string>
    <string name="data_warning" msgid="2925054658166062884">"Datawaarskuwing"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"Datawaarskuwing en datalimiet word deur jou toestel gemeet. Dit kan van die diensverskafferdata verskil."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Stel datalimiet"</string>
    <string name="data_limit" msgid="8731731657513652363">"Datalimiet"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_1">%1$s</xliff:g> in <xliff:g id="ID_2">%2$s</xliff:g> gebruik"</string>
    <string name="configure" msgid="1499586749829665889">"Stel op"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Ander programme wat by gebruik ingesluit is"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 app word toegelaat om onbeperkte data te gebruik wanneer Databespaarder aan is}other{# apps word toegelaat om onbeperkte data te gebruik wanneer Databespaarder aan is}}"</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> is gebruik"</string>
    <string name="data_overusage" msgid="3680477320458707259">"<xliff:g id="ID_1">^1</xliff:g> oor"</string>
    <string name="data_remaining" msgid="6316251496381922837">"<xliff:g id="ID_1">^1</xliff:g> oor"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Grafiek wat datagebruik tussen <xliff:g id="START_DATE">%1$s</xliff:g> en <xliff:g id="END_DATE">%2$s</xliff:g> wys."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Geen data in hierdie datumreeks nie"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{# dag oor}other{# dae oor}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Geen tyd oor nie"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Minder as 1 dag oor"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"<xliff:g id="ID_2">^2</xliff:g> gelede opgedateer deur <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"<xliff:g id="ID_1">^2</xliff:g> gelede opgedateer"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Sopas opgedateer deur <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Sopas opgedateer"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Bekyk besonderhede"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Databespaarder"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Onbeperkte data"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Agtergronddata is afgeskakel"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Aan"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Af"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Gebruik Databespaarder"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Onbeperkte datagebruik"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Onbeperkte toegang tot data as Databespaarder aan is"</string>
    <string name="home_app" msgid="6056850504746902747">"Tuis-program"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Voeg nog \'n vingerafdruk by"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Ontsluit met \'n ander vinger"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Aan"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Sal aanskakel op <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Af"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Programbatterygebruik"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Stel batterygebruik vir programme"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"Bekyk instellings"</string>
    <string name="battery_tips_card_action_button_check" msgid="1535140204105479318">"Kontroleer"</string>
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"Het dit"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"Is hierdie boodskap nuttig?"</string>
    <string name="battery_hints_warning_icon_a11y" msgid="5312542323401447620">"Batterywenke-waarskuwingikoon"</string>
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Skakel aanpasbare helderheid aan om die batterylewe te verleng"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Verkort skermuitteltyd om die batterylewe te verleng"</string>
    <string name="battery_tips_apps_summary_always_high" msgid="6334519477067044920">"<xliff:g id="APP_LABEL">%1$s</xliff:g> het meer batterykrag gebruik"</string>
    <string name="battery_tips_apps_summary_higher_than_usual" msgid="95676961671544628">"<xliff:g id="APP_LABEL">%1$s</xliff:g> het meer batterykrag as gewoonlik gebruik"</string>
    <string name="battery_tips_apps_summary_always_high_in_background" msgid="2953858181710181126">"<xliff:g id="APP_LABEL">%1$s</xliff:g> het meer batterykrag gebruik terwyl dit op die agtergrond was"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_background" msgid="1585002072567422199">"<xliff:g id="APP_LABEL">%1$s</xliff:g> het meer batterykrag as gewoonlik gebruik terwyl dit op die agtergrond was"</string>
    <string name="battery_tips_apps_summary_always_high_in_foreground" msgid="1910991243576404700">"<xliff:g id="APP_LABEL">%1$s</xliff:g> het meer batterykrag gebruik terwyl dit op die voorgrond was"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground" msgid="7937337570425168210">"<xliff:g id="APP_LABEL">%1$s</xliff:g> het meer batterykrag as gewoonlik gebruik terwyl dit op die voorgrond was"</string>
    <string name="battery_usage_anomaly_content_description" msgid="3199380151630770476">"Onreëlmatigheid met batterygebruik"</string>
    <string name="battery_app_item_hint" msgid="4850929961461039110">"Hoë batterygebruik"</string>
    <string name="battery_app_item_hint_in_bg" msgid="596240821466388336">"Hoë batterygebruik op die agtergrond"</string>
    <string name="battery_app_item_hint_in_fg" msgid="5091860632260799910">"Hoë batterygebruik op die voorgrond"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Onbeperk"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Geoptimeer"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Beperk"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Verstekspeltoetser"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Kies speltoetser"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Gebruik speltoetser"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Nie gekies nie"</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">"sleutel"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"groep"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(opsomming)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"publicVersion"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"belangrikheid"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"verduideliking"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"kan kenteken wys"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"voorneme"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"vee voorneme uit"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"volskermvoorneme"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"handelinge"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"titel"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"afgeleë insette"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"gepasmaakte aansig"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"ekstras"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ikoon"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"pakkiegrootte"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"kennisgewing gewaarsku"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"kanaal"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Graderingvoorwerp ontbreek."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"Graderingvoorwerp bevat nie hierdie sleutel nie."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Skermuitsnede"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"skermuitsnede, uitkeep"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Toestelverstek"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Kon nie oorlegger toepas nie"</string>
    <string name="special_access" msgid="1767980727423395147">"Spesiale apptoegang"</string>
    <string name="special_access_more" msgid="132919514147475846">"Sien meer"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Lang agtergrondtake"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Laat agtergrondtake toe wat lank neem"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Lang agtergrondtake"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Laat hierdie app toe om lang agtergrondtake uit te voer. Dit laat die app toe om take uit te voer wat langer as ’n paar minute kan neem om te voltooi, soos aflaaie en oplaaie. \n\nAs hierdie toestemming geweier word, sal die stelsel beperk hoe lank die app sulke take op die agtergrond kan uitvoer."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"lang take, dataoordrag, agtergrondtake"</string>
    <string name="run_backup_tasks_title" msgid="8572480651659803275">"Voer rugsteuntake in die agtergrond uit"</string>
    <string name="run_backup_tasks_switch_title" msgid="4740767959730361777">"Laat app toe om rugsteunverwante agtergrondtake te laat loop"</string>
    <string name="run_backup_tasks_footer_title" msgid="1766222193265152388">"Dit dui aan dat hierdie app \'n groot gebruikgeval het waar dit nodig is om inhoud te rugsteun of te sinkroniseer. As jy hierdie toestemming gee, laat dit die app toe om vir \'n bietjie langer in die agtergrond te loop om sodoende die rugsteunverwante werk te voltooi. \n\nAs hierdie toestemming geweier word, sal die stelsel nie enige spesiale vrystelling aan hierdie app gee om die rugsteunverwante werk in die agtergrond te voltooi nie."</string>
    <string name="keywords_run_backup_tasks" msgid="632219905465766211">"rugsteun take rugsteun werksoek"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Stel ShortcutManager se koersbeperking terug"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"ShortcutManager se koersbeperking is teruggestel"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Beheer inligting op sluitskerm"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Wys of versteek kennisgewinginhoud"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Wenke en steundiens"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Kleinste breedte"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Geen geïnstalleerde programme het toegang tot betaalde SMS\'e versoek nie"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"Betaalde SMS\'e kan jou geld kos en die koste sal by jou diensverskafferfakture gevoeg word. As jy toestemming vir \'n program aktiveer, sal jy betaalde SMS\'e met daardie program kan stuur."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Toegang tot betaalde SMS\'e"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Af"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Gekoppel aan <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Gekoppel aan veelvuldige toestelle"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Stelsel-UI-demonstrasiemodus"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Donkertema"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Tydelik gedeaktiveer vanweë Batterybespaarder"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Tydelik gedeaktiveer vanweë Batterybespaarder"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Skakel batterybespaarder af"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Tydelik aangeskakel vanweë Batterybespaarder"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Probeer Donkertema"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Help om batterylewe te verleng"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Kitsinstellings-ontwikkelaarteëls"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Deaktiveer uitteltyd vir ADB-magtiging"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Deaktiveer outomatiese herroeping van ADB-magtigings vir stelsels wat nie binne die verstek- (7 dae) of gebruikeropgstelde (minimum 1 dag) tydperk herkoppel het nie."</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Sensors Af"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Werkprofielinstellings"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Soek werkgidskontakte in persoonlike apps"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Jou IT-admin sal dalk jou soektogte en inkomende oproepe kan sien"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Kruisprofielkalender"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Wys werkgeleenthede op jou persoonlike kalender"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Wanneer werkapps af is, is hulle onderbreek. Hulle kan nie vir jou kennisgewings stuur nie en jy kan nie toegang tot hulle kry nie"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Bestuur berging"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Bergingbestuurder verwyder gerugsteunde foto\'s en video\'s van jou toestel af om te help om berginspasie beskikbaar te maak."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Verwyder foto\'s en video\'s"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Bergingbestuurder"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Gebruik Bergingbestuurder"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gebare"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Maak kamera vinnig oop"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Druk die aan/af-skakelaar twee keer om die kamera vinnig oop te maak. Dit werk op enige skerm."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Draai kamera om vir selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Navigasiemodus"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"2-knoppienavigasie"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Swiep op op die tuisknoppie om programme te wissel. Swiep weer op om alle programme te sien. Tik op die terugknoppie om terug te gaan."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Veiligheid en noodgeval"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Nood-SOS, mediese inligting, waarskuwings"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Gebaarnavigasie"</string>
    <string name="edge_to_edge_navigation_summary" msgid="818109176611921504">"Swiep op van die onderkant van die skerm af om na die tuisskerm toe te gaan. Swiep op van die onderkant af, hou, en los dan om apps te wissel. Swiep van óf die linker- óf die regterrand af om terug te gaan."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"3-knoppienavigasie"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Gaan terug, Tuis, en wissel apps met knoppies onderaan jou skerm."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"stelselnavigasie, 2-knoppienavigasie, 3-knoppienavigasie, gebaarnavigasie, swiep"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Digitale assistent"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Swiep om assistent op te roep"</string>
    <string name="assistant_corner_gesture_summary" msgid="5012534700233017955">"Swiep op van ’n onderste hoek af om digitale bystandapp op te roep"</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Hou Tuis vir Assistent"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Druk en hou die tuisknoppie om digitaleasistentprogram op te roep."</string>
    <string name="low_label" msgid="6525629096999711220">"Laag"</string>
    <string name="high_label" msgid="357503396626018487">"Hoog"</string>
    <string name="left_edge" msgid="1513576842959071849">"Linkerrand"</string>
    <string name="right_edge" msgid="1505309103265829121">"Regterrand"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"Hoër sensitiwiteit kan konflik met enige programgebare aan die rande van die skerm veroorsaak."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Agtersensitiwiteit"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Sensitiwiteit van gebaarnavigasie"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Knoppienavigasie"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"gebaarnavigasie, agtersensitiwiteit, teruggebaar"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navigasie, tuisknoppie"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Eenhandmodus"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Gebruik eenhandmodus"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Kortpad vir eenhandmodus"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"bereikbaarheid"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Swiep af om die volgende te doen:"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Gebruik die kortpad om"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Trek die boonste helfte van jou skerm af sodat jy dit makliker met een hand kan bereik"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Hoe om eenhandmodus te gebruik"</b>\n" • Maak seker dat jy gebaarnavigasie in stelselnavigasie-instellings kies\n • Swiep af na die onderkant van die skerm"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Trek skerm na binne jou bereik"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Die bokant van die skerm sal skuif om binne bereik van jou duim te wees."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Wys kennisgewings"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Kennisgewings en instellings sal verskyn."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Dubbeltik op jou skerm om na die horlosie, kennisgewings en ander inligting te kyk."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Ontwaakskerm"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Tik op jou skerm om na die horlosie, kennisgewings en ander inligting te kyk."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Nood-SOS"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Gebruik nood-SOS"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Druk die aan/af-skakelaar 5 of meer keer vinnig om die handelinge hieronder te begin"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Speel aftelwekker"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Speel \'n harde klank wanneer nood-SOS begin"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Stel in kennis vir hulp"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Bel vir hulp"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Nommer om te bel vir hulp"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Tik om te verander"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"As jy \'n nommer invoer wat nie \'n noodnommer is nie:\n • Moet jou toestel ontsluit wees om nood-SOS te gebruik\n • Sal jou oproep dalk nie beantwoord word nie"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Swiep vingerafdruk vir kennisgewings"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Swiep vingerafdruk"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Sien kennisgewings vinnig"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Aan"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Af"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"Selflaaiprogram is reeds ontsluit"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Koppel aan die internet of kontak jou diensverskaffer"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Onbeskikbaar op toestelle wat deur diensverskaffer gesluit is"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Herbegin asseblief jou toestel om toestelbeskermingkenmerk te aktiveer."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Altesame <xliff:g id="SIZE">%1$s</xliff:g> is beskikbaar gemaak\n\nLaas op <xliff:g id="DATE">%2$s</xliff:g> laat loop"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Kitsprogramme"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Maak skakels in programme oop, selfs as hulle nie geïnstalleer is nie"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Kitsprogramme"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Kitsprogramvoorkeure"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Geïnstalleerde programme"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Jou berging word nou deur die bergingbestuurder bestuur"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Rekeninge vir <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Sinkroniseer programdata outomaties"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Laat apps data outomaties herlaai"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Rekeningsinkronisering"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sinkronisering is aan vir <xliff:g id="ID_1">%1$d</xliff:g> van <xliff:g id="ID_2">%2$d</xliff:g> items"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sinkronisering is aan vir alle items"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sinkronisering af vir alle items"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Inligting oor bestuurde toestel"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Veranderinge en instellings wat deur jou organisasie bestuur word"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Veranderinge en instellings wat deur <xliff:g id="ORGANIZATION_NAME">%s</xliff:g> bestuur word"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Om toegang tot jou werkdata te verskaf, sal jou organisasie dalk instellings verander en sagteware op jou toestel installeer.\n\nKontak jou organisasie se administrateur vir meer besonderhede."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Soort inligting wat jou organisasie kan sien"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Veranderinge wat deur jou organisasie se administrateur gemaak is"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Jou toegang tot hierdie toestel"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Data wat met jou werkrekening geassosieer word, soos e-pos en kalender"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Lys programme op jou toestel"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Hoeveelheid tyd en data wat in elke program bestee is"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Mees onlangse netwerkverkeer-loglêer"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Mees onlangse foutverslag"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Mees onlangse sekuriteitloglêer"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Geen"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Programme is geïnstalleer"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"Aantal programme is geskat. Dit sluit dalk nie programme in wat buite die Play Winkel geïnstalleer is nie."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Minimum # app}other{Minimum # apps}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Liggingtoestemmings"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Mikrofoontoestemmings"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Kameratoestemmings"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Verstekprogramme"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# app}other{# apps}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Versteksleutelbord"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Gestel na <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Altyd-aan-VPN is aangeskakel"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Altyd-aan-VPN is in jou persoonlike profiel aangeskakel"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Altyd-aan-VPN is in jou werkprofiel aangeskakel"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Globale HTTP-instaanbediener is gestel"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Vertroude eiebewyse"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Vertroude eiebewyse in jou persoonlike profiel"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Vertroude eiebewyse in jou werkprofiel"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Minimum # CA-sertifikaat}other{Minimum # CA-sertifikate}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"Die administrateur kan die toestel sluit en die wagwoord terugstel"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"Die administrateur kan alle toesteldata uitvee"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Mislukte wagwoordpogings voordat alle toesteldata uitgevee word"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Mislukte wagwoordpogings voordat alle werkprofieldata uitgevee word"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# poging}other{# pogings}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Hierdie toestel word deur jou organisasie bestuur."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Hierdie toestel word deur <xliff:g id="ORGANIZATION_NAME">%s</xliff:g> bestuur."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Kom meer te wete"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Beperkte instelling"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Beperkte instellings toegelaat vir <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Hierdie instelling is vir jou veiligheid tans onbeskikbaar."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Inligting oor gefinansierde toestelle"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Jou kredietverskaffer kan tydens die opstelling instellings verander en sagteware op hierdie toestel installeer.\n\nAs jy ’n betaling mis, kan jou kredietverskaffer jou toestel sluit en toestelinstellings verander.\n\nKontak jou kredietverskaffer om meer te wete te kom."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"As jou toestel gefinansier word, kan jy nie:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Programme van buite die Play Winkel af installeer nie"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Jou toestel herselflaai na veilige modus toe nie"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Veelvuldige gebruikers by jou toestelle voeg nie"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Die datum, tyd en tydsones verander nie"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Ontwikkelaaropsies gebruik nie"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Jou kredietverskaffer kan:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Toegang tot jou IMEI-nommer kry"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"’n Fabriekterugstelling van jou toestel doen as iets verkeerd loop"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"As jou toestel gesluit is, kan jy dit net gebruik om:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Noodoproepe te maak"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Na stelselinligting soos datum, tyd, netwerkstatus en battery te kyk"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Jou toestel aan of af te skakel"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Kennisgewings en SMS\'e te bekyk"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Toegang te kry tot programme wat deur die kredietverskaffer toegelaat word"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Nadat jy die volle bedrag betaal het:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Word alle beperkings van die toestel af verwyder"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Kan jy die krediteurprogram deïnstalleer"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Inligting oor gefinansierde toestelle"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{Kamera-app}other{Kamera-apps}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"Kalenderprogram"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"Kontakteprogram"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{E-poskliëntapp}other{E-poskliëntapps}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"Kaartprogram"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{Foonapp}other{Foonapps}}"</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">"Hierdie toestel"</string>
    <string name="storage_games" msgid="1176568610086802469">"Speletjies"</string>
    <string name="storage_files" msgid="7968460921272772299">"Lêers"</string>
    <string name="storage_images" msgid="2055893015567979387">"Prente"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Video\'s"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Oudio"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Apps"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Dokumente en ander"</string>
    <string name="storage_system" msgid="8472410119822911844">"Stelsel"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Asblik"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Maak asblik leeg?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Daar is <xliff:g id="TOTAL">%1$s</xliff:g> lêers in die asblik. Alle items sal vir altyd uitgevee word en jy sal hulle nie kan teruglaai nie."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"Asblik is leeg"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Maak asblik leeg"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> gebruik"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"Altesaam <xliff:g id="NUMBER">%1$s</xliff:g><xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Maak program skoon"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Wil jy hierdie kitsprogram verwyder?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Maak oop"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Speletjies"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Gebruikte spasie"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(gedeïnstalleer vir gebruiker <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(gedeaktiveer vir gebruiker <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Outovuldiens"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Verstekoutovuldiens"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Wagwoorde"</string>
    <string name="credman_chosen_app_title" msgid="7735183808067729319">"Voorkeurdiens"</string>
    <string name="credman_credentials" msgid="2620352336624160642">"Bykomende dienste"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# wagwoord}other{# wagwoorde}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"outomaties, invul, outovul, wagwoord"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"data, toegangsleutel, wagwoord"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"outo, vul, outovul, data, toegangsleutel, wagwoord"</string>
    <string name="credman_button_change" msgid="4072629639218503790">"Verander"</string>
    <string name="credman_button_open" msgid="7519871964170816850">"Maak oop"</string>
    <string name="credman_app_list_preference_none" msgid="2509646651254971448">"Niks is gekies nie"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Maak seker dat jy hierdie program vertrou&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google Outovul&gt;%1$s&lt;/xliff:g&gt; gebruik wat op jou skerm is om te bepaal wat outomaties ingevul kan word."</string>
    <string name="credman_autofill_confirmation_message" msgid="843829628024668466">"&lt;b&gt;Gebruik &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Nuwe wagwoorde, toegangsleutels en ander inligting sal van nou af hier gestoor word. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; kan dalk gebruik wat op jou skerm is om te bepaal wat outomaties ingevul kan word."</string>
    <string name="credman_picker_title" msgid="8442086614222006564">"Voorkeurdiens vir wagwoorde, toegangsleutels en outovul"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Skakel %1$s af?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Skakel hierdie diens af?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Gestoorde inligting soos wagwoorde, toegangsleutels, betaalmetodes en ander inligting sal nie ingevul word wanneer jy aanmeld nie. Kies ’n wagwoord, toegangsleutel of datadiens om jou gestoorde inligting te gebruik."</string>
    <string name="account_dashboard_title_with_passkeys" msgid="6214673787161409996">"Wagwoorde, toegangsleutels en outovul"</string>
    <string name="credman_confirmation_message_new_ui" msgid="6126274509951156460">"&lt;b&gt;Skakel alle dienste af?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Wagwoorde, toegangsleutels en ander gestoorde inligting sal nie vir outovul beskikbaar wees wanneer jy aanmeld nie"</string>
    <string name="credman_autofill_confirmation_message_new_ui" msgid="6222139222478822267">"&lt;b&gt;Verander jou voorkeurdiens na &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Nuwe wagwoorde, toegangsleutels en ander inligting sal van nou af hier gestoor word. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; kan dalk gebruik wat op jou skerm is om te bepaal wat outomaties ingevul kan word"</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Gebruik %1$s?"</string>
    <string name="credman_confirmation_turn_off_positive_button" msgid="5678773011513369161">"Skakel af"</string>
    <string name="credman_confirmation_change_provider_positive_button" msgid="7732302992885116967">"Verander"</string>
    <string name="credman_limit_error_msg_title" msgid="1525814645803612135">"Jy kan net 5 dienste aan hê"</string>
    <string name="credman_limit_error_msg" msgid="2521803280130310063">"Skakel ten minste 1 diens af om nog een by te voeg"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s gebruik wat op jou skerm is om te bepaal wat outomaties ingevul kan word."</string>
    <string name="credman_error_message_title" msgid="4099557206946333568">"Limiet vir wagwoorde, toegangsleutels en datadienste"</string>
    <string name="credman_error_message" msgid="8334797097200415449">"Jy kan tot 5 wagwoorde, toegangsleutels en datadienste tegelyk aktief hê. Skakel ’n diens af om meer by te voeg."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Skakel af"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Outovul"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Aantekeningvlak"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Maksimum aantal versoeke per sessie"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Maksimum aantal sigbare datastelle"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Stel terug na verstekwaardes"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Outovul-ontwikkelaaropsies is teruggestel"</string>
    <string name="location_category" msgid="3496759112306219062">"Ligging"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Statusbalkligging-aanduier"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Wys vir alle liggings, insluitend netwerk en konnektiwiteit"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Dwing volle GNSS-metings af"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Spoor alle GNSS-konstellasies en -frekwensies na sonder enige dienssiklussering"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Invoermetode"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Stilushandskrif"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Wanneer dit geaktiveer is, kan die huidige invoermetode ’n stilus-beweginggebeurtenis ontvang as ’n redigeerder ingestel is."</string>
    <string name="device_theme" msgid="5027604586494772471">"Toesteltema"</string>
    <string name="default_theme" msgid="4815428567082263639">"Verstek"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Netwerknaam"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Vertoon netwerknaam in statusbalk"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"Kitsprogram"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Skakel die bergingbestuurder af?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Dateer Moenie Steur Nie op"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Onderbreek kennisgewings om gefokus te bly"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Kenmerk is nie beskikbaar nie"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Hierdie kenmerk is afgeskakel omdat dit jou foon stadiger maak"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Wys altyd omvaldialoog"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Wys dialoog elke keer as \'n program omval"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Kies ANGLE-geaktiveerde program"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Geen ANGLE-gekativeerde program gestel nie"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"ANGLE-geaktiveerde program: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Grafikadrywervoorkeure"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Wysig grafikadrywerinstellings"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Wanneer daar veelvuldige grafikadrywers is, kan jy kies om die opgedateerde grafikadrywer te gebruik vir programme wat op die toestel geïnstalleer is."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Aktiveer vir alle programme"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Kies grafikadrywer"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Verstek"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Speletjiedrywer"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Ontwikkelaardrywer"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Stelselgrafikadrywer"</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">"Eksperimenteel: aktiveer ANGLE"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="2170215556348477481">"Waarskuwing: aktiveer ANGLE as verstek-OpenGL ES-drywer. Hierdie kenmerk is eksperimenteel en sal dalk nie met sommige kamera- en videoapps versoenbaar wees nie."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"’n Herselflaai word vereis om die stelsel-OpenGL ES-drywer te verander"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Veranderinge aan programversoenbaarheid"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Wissel veranderinge aan programversoenbaarheid"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Veranderinge aan by verstek geaktiveer"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Veranderinge aan by verstek gedeaktiveer"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Veranderinge aan programversoenbaarheid kan net vir ontfoutbare programme gewysig word. Installeer \'n ontfoutbare program en probeer weer."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Hang van \'n ander instelling af"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Rekening"</string>
    <string name="my_device_info_account_preference_summary" msgid="3510582677937510545">"%d rekeninge"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Toestelnaam"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Basiese inligting"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Wetlik en regulerend"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Toestelbesonderhede"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Toestelidentifiseerders"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Wi-Fi-beheer"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Laat program toe om Wi-Fi te beheer"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Laat hierdie program toe om Wi-Fi aan of af te skakel, Wi-Fi-netwerke te soek en aan hulle te koppel, netwerke by te voeg en te verwyder, en om \'n slegsplaaslike warmkol te begin"</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Begin via NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Laat toe dat dit met NFC-skandering begin"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Laat hierdie app toe om te begin wanneer ’n NFC-merker geskandeer word.\nAs hierdie toestemming aan is, sal die app as ’n opsie beskikbaar wees elke keer wanneer ’n merker bespeur word."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Speel media na"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Speel <xliff:g id="LABEL">%s</xliff:g> op"</string>
    <string name="media_output_title_without_playing" msgid="3339321669132875821">"Oudio sal speel op"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Hierdie toestel"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Onbeskikbaar tydens oproepe"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Antwoord oproep op"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Hierdie toegangspuntnaam kan nie verander word nie."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Keer dat dit lui"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Druk Aan/af-skakelaar en Volume Harder saam vir"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Kortpad om te voorkom dat toestel lui"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibreer"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Demp"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibreer"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Demp"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"As jy wil aktiveer, moet jy eers \"Druk en hou aan/af-skakelaar\" na die aan/af-kieslys verander."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Netwerkbesonderhede"</string>
    <string name="devices_title" msgid="649715719278562515">"Toestelle"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Kies netwerk"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Ontkoppel"</string>
    <string name="network_connected" msgid="7637745547242487795">"Gekoppel"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Koppel tans …"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Kon nie koppel nie"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Geen netwerke gekry nie."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Kon nie netwerke kry nie. Probeer weer."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(verbode)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Geen SIM nie"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Geen"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Benodig SIM om te koppel"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Benodig <xliff:g id="WIRELESS_CARRIER">%s</xliff:g>-SIM om te koppel"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Voorkeurnetwerkmodus: WCDMA verkies"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Voorkeurnetwerkmodus: net GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Voorkeurnetwerkmodus: net WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Voorkeurnetwerkmodus: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Voorkeurnetwerkmodus: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Voorkeurnetwerkmodus: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Voorkeurnetwerkmodus: net CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Voorkeurnetwerkmodus: net EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Voorkeurnetwerkmodus: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Voorkeurnetwerkmodus: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Voorkeurnetwerkmodus: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Voorkeurnetwerkmodus: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Voorkeurnetwerkmodus: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Voorkeurnetwerkmodus: globaal"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Voorkeurnetwerkmodus: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Voorkeurnetwerkmodus: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Voorkeurnetwerkmodus: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Voorkeurnetwerkmodus: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Voorkeurnetwerkmodus: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Voorkeurnetwerkmodus: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Voorkeurnetwerkmodus: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Voorkeurnetwerkmodus: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Voorkeurnetwerkmodus: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Voorkeurnetwerkmodus: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Voorkeurnetwerkmodus: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Voorkeurnetwerkmodus: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Voorkeurnetwerkmodus: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Voorkeurnetwerkmodus: net NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Voorkeurnetwerkmodus: NR / LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Voorkeurnetwerkmodus: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Voorkeurnetwerkmodus: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Voorkeurnetwerkmodus: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Voorkeurnetwerkmodus: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Voorkeurnetwerkmodus: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Voorkeurnetwerkmodus: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Voorkeurnetwerkmodus: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Voorkeurnetwerkmodus: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Voorkeurnetwerkmodus: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (aanbeveel)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (aanbeveel)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (aanbeveel)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Kies netwerk outomaties"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Diensverskafferstellings"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Stel datadiens op"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Mobiele data"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Kry toegang tot data deur selnetwerk"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"Foon sal outomaties na hierdie diensverskaffer oorskakel wanneer dit binne bereik is"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Geen SIM beskikbaar nie"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Oproepevoorkeur"</string>
    <string name="sms_preference" msgid="7742964962568219351">"SMS-voorkeur"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Vra elke keer"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Voeg \'n netwerk by"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Verstek vir oproepe"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Verstek vir SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Verstek vir oproepe en SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Verstek vir mobiele data"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Mobiele data aktief"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Mobiele data af"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Beskikbaar"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Voeg SIM by"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Aktief / SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Onaktief / SIM"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Aktief/e-SIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Onaktief/e-SIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"SIM-naam en -kleur"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Naam"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Kleur (gebruik deur versoenbare programme)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Stoor"</string>
    <string name="mobile_network_use_sim_on" msgid="5333182776279917886">"Gebruik hierdie SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Af"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="7182341033728911879">"Verwyder die SIM-kaart om hierdie SIM af te skakel"</string>
    <string name="mobile_network_tap_to_activate" msgid="5280456487243915465">"Tik om jou <xliff:g id="CARRIER">%1$s</xliff:g>-SIM te aktiveer"</string>
    <string name="mobile_network_erase_sim" msgid="5387971155494245850">"Vee e-SIM uit"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Voorkeurnetwerktipe"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Verander die netwerkbedryfsmodus"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Voorkeurnetwerktipe"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Diensverskafferinstellingsweergawe"</string>
    <string name="call_category" msgid="641461844504128789">"Oproepe"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Diensverskaffervideo-oproepe"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Stelselkeuse"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Verander die CDMA-swerwingmodus"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Stelselkeuse"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Netwerk"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"CDMA-intekening"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Wissel tussen RUIM/SIM en NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"intekening"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Outomatiese registrasie …"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Laat dataswerwing toe?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Kry pryse by jou netwerkverskaffer."</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Ongeldige netwerkmodus <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignoreer."</string>
    <string name="satellite_setting_title" msgid="2543034229989047673">"Satellietboodskappe"</string>
    <string name="satellite_setting_enabled_summary" msgid="3554127722727530845">"Stuur en ontvang teksboodskappe via satelliet. Ingesluit by jou rekening."</string>
    <string name="satellite_setting_disabled_summary" msgid="6789122487534159857">"Stuur en ontvang teksboodskappe via satelliet. Nie by jou rekening ingesluit nie."</string>
    <string name="keywords_satellite_setting" msgid="3312183289776517695">"Satellietboodskappe"</string>
    <string name="category_name_about_satellite_messaging" msgid="3756205049485508340">"Meer oor satellietboodskappe"</string>
    <string name="title_about_satellite_setting" msgid="9212860038048311345">"Jy kan as deel van ’n kwalifiserende <xliff:g id="CARRIER_NAME">%1$s</xliff:g>-rekening teksboodskappe via satelliet stuur en ontvang."</string>
    <string name="category_title_your_satellite_plan" msgid="3017895097366691841">"Jou <xliff:g id="CARRIER_NAME">%1$s</xliff:g>-pakket"</string>
    <string name="title_have_satellite_plan" msgid="2048372355699977947">"Satellietboodskappe is by jou rekening ingesluit"</string>
    <string name="title_no_satellite_plan" msgid="2876056203035197505">"Satellietboodskappe is nie by jou rekening ingesluit nie"</string>
    <string name="summary_add_satellite_setting" msgid="3815254731634052432">"Voeg satellietboodskappe by"</string>
    <string name="category_name_how_it_works" msgid="585303230539269496">"Hoe dit werk"</string>
    <string name="title_satellite_connection_guide" msgid="3294802307913609072">"As jy nie ’n selnetwerk het nie"</string>
    <string name="summary_satellite_connection_guide" msgid="3496123195218418456">"Jou foon sal outomaties aan ’n satelliet verbind. Vir die beste verbinding, maak seker jy kan die lug duidelik sien."</string>
    <string name="title_supported_service" msgid="4275535165812691571">"Nadat jou foon aan ’n satelliet verbind"</string>
    <string name="summary_supported_service" msgid="4320535903444834786">"Jy kan ’n teksboodskap na enigiemand stuur, insluitend nooddienste. Jou foon sal weer aan ’n selnetwerk verbind wanneer dit beskikbaar is."</string>
    <string name="satellite_setting_summary_more_information" msgid="4008690241760925372">"Satellietboodskappe kan langer neem en is net in sekere gebiede beskikbaar. Die weer en sekere strukture kan jou satellietverbinding affekteer. Oproepe via satelliet is nie beskikbaar nie.\n\nDit kan ’n tydjie neem voor veranderinge aan jou rekening in Instellings sal wys. Kontak <xliff:g id="CARRIER_NAME">%1$s</xliff:g> vir besonderhede."</string>
    <string name="more_about_satellite_messaging" msgid="3385673133561348509">"Meer oor satellietboodskappe"</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Toegangspuntname"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"APN"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Onbeskikbaar wanneer gekoppel aan <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Sien meer"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Skakel <xliff:g id="CARRIER_NAME">%1$s</xliff:g> aan?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Skakel SIM aan?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Skakel oor na <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Skakel oor om SIM-kaart te gebruik?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Gebruik <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="7474905814976249607">"Net 1 SIM op ’n slag kan aan wees.\n\nOorskakeling na <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> sal nie jou <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>-diens kanselleer nie."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="6415848271400253954">"Net 1 e-SIM op ’n slag kan aan wees.\n\nOorskakeling na <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> sal nie jou <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>-diens kanselleer nie."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="421658355882679837">"Net 1 SIM op ’n slag kan aan wees.\n\nOorskakeling sal nie jou <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>-diens kanselleer nie."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Jy kan 2 SIM\'s op dieselfde tyd gebruik. Skakel ander SIM af om <xliff:g id="CARRIER_NAME">%1$s</xliff:g> te gebruik."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Skakel oor na <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">"Skakel <xliff:g id="CARRIER_NAME">%1$s</xliff:g> af"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"As jy \'n SIM afskakel, sal dit nie jou diens kanselleer nie"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="8144175623622669136">"Aktiveer tans jou SIM …"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="697127154780501304">"Skakel tans oor na <xliff:g id="CARRIER_NAME">%1$s</xliff:g> …"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="2718084141744769701">"Kan nie SIM-kaarte wissel nie"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="8332742656111984482">"Iets het skeefgeloop. Kan nie SIM-kaarte wissel nie."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Skakel <xliff:g id="CARRIER_NAME">%1$s</xliff:g> af?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Skakel SIM af?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Skakel tans SIM af <xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="1808735136395980905">"Kan nie SIM afskakel nie"</string>
    <string name="privileged_action_disable_fail_text" msgid="6236231745255527458">"Iets het skeefgeloop en jou SIM kon nie afgeskakel word nie."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Gebruik 2 SIM-kaarte?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Hierdie toestel kan 2 SIM-kaarte op dieselfde tyd aktief hê. Tik op \"Nee, dankie\" om aan te hou om 1 SIM op \'n slag te gebruik."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Herbegin toestel?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Ja"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Herbegin"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Nee, dankie"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Kanselleer"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Skakel oor"</string>
    <string name="sim_action_turn_off" msgid="3506698692916473000">"Skakel af"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Kan nie SIM aktiveer nie"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Probeer weer om die SIM aan te skakel. Herbegin jou toestel as die probleem voortduur."</string>
    <string name="sim_onboarding_bottomsheets_title" msgid="143711121394213711">"Stel jou SIM op"</string>
    <string name="sim_onboarding_bottomsheets_msg" msgid="7367245016476460849">"Sstel jou selnetwerkvoorkeure om veelvuldige SIM’s op hierdie toestel te gebruik"</string>
    <string name="sim_onboarding_label_sim_title" msgid="273162565849288273">"Merk jou SIM’s"</string>
    <string name="sim_onboarding_label_sim_msg" msgid="5105859235219529056">"Jy sal hierdie etikette in Instellings sien en wanneer jy oproepe maak, SMS’e stuur en data gebruik"</string>
    <string name="sim_onboarding_label_sim_dialog_title" msgid="5839073125605286120">"SIM-etiket"</string>
    <string name="sim_onboarding_label_sim_dialog_label" msgid="9020433985426525185">"Etiket"</string>
    <string name="sim_onboarding_select_sim_title" msgid="5895262188167744055">"Kies watter SIM’s om te gebruik"</string>
    <string name="sim_onboarding_select_sim_msg" msgid="5638859405391915048">"Jy kan 2 SIM’s op ’n slag gebruik"</string>
    <string name="sim_onboarding_primary_sim_title" msgid="2793090401371135675">"Stel jou primêre SIM’s"</string>
    <string name="sim_onboarding_primary_sim_msg" msgid="5484656671490558032">"Kies watter SIM’s om by verstek te gebruik vir oproepe, SMS’e en data"</string>
    <string name="primary_sim_title" msgid="2508161011657571566">"Jou primêre SIM’s"</string>
    <string name="primary_sim_calls_title" msgid="4961189133582615685">"Oproepe"</string>
    <string name="primary_sim_texts_title" msgid="1287584042733097749">"SMS’e"</string>
    <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Outomatiese datawisseling"</string>
    <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Gebruik data vanaf enige SIM na gelang van dekking en beskikbaarheid"</string>
    <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Net data"</string>
    <string name="sim_onboarding_setup" msgid="5750393553605388463">"Stel op"</string>
    <string name="sim_onboarding_next" msgid="6415025179929475355">"Volgende"</string>
    <string name="sim_onboarding_progressbar_turning_sim_on" msgid="1163318788393361574">"Skakel tans <xliff:g id="CARRIER_NAME">%1$s</xliff:g> aan …"</string>
    <string name="mobile_network_spn_title" msgid="3053793174495329077">"Selnetwerk"</string>
    <string name="mobile_network_phone_number_title" msgid="2090794402855021784">"Foonnommer"</string>
    <string name="mobile_network_sim_label_color_title" msgid="2401352348041132876">"SIM-etiket en -kleur"</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Netwerkaktivering"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Diensverskafferoorskakeling"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="975447139749692794">"Jou <xliff:g id="CARRIER_NAME">%1$s</xliff:g>-SIM is aktief"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Tik om SIM-instellings op te dateer"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Gewissel na <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Gewissel na \'n ander diensverskaffer"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Jou selnetwerk het verander"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Stel jou ander SIM op"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Kies jou aktiewe SIM of gebruik tegelyk 2 SIM\'s"</string>
    <string name="choose_sim_title" msgid="66509047151583877">"Kies ’n SIM om te gebruik"</string>
    <string name="choose_sim_text" msgid="8992163497852069924">"{count,plural, =1{1 SIM is op hierdie toestel beskikbaar, maar net een kan op \'n slag gebruik word}=2{2 SIM-kaarte is op hierdie toestel beskikbaar, maar net een kan op \'n slag gebruik word}other{# SIM-kaarte is op hierdie toestel beskikbaar, maar net een kan op \'n slag gebruik word}}"</string>
    <string name="choose_sim_activating" msgid="6485547671356386998">"Skakel tans aan <xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="866488735834045525">"Kon nie op die oomblik hierdie SIM aanskakel nie"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Gebruik <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> sal vir mobiele data, oproepe en SMS\'e gebruik word"</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Geen aktiewe SIM-kaarte beskikbaar nie"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Gaan na jou netwerkinstellings om mobiele data, oproepkenmerke en SMS\'e later te kan gebruik"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Vee hierdie e-SIM uit?"</string>
    <string name="erase_sim_dialog_text" msgid="1406141218170595272">"Dit verwyder <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> se diens van hierdie toestel af, maar jou <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g>-pakket sal nie gekanselleer word nie."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Vee uit"</string>
    <string name="erasing_sim" msgid="4237180547590463930">"e-SIM word uitgevee …"</string>
    <string name="erase_sim_fail_title" msgid="1445700500168357303">"Kan nie e-SIM uitvee nie"</string>
    <string name="erase_sim_fail_text" msgid="6898841004987411547">"Iets het skeefgeloop en hierdie e-SIM is nie uitgevee nie.\n\nHerbegin jou toestel en probeer weer."</string>
    <string name="wifi_warning_dialog_title" msgid="7328515476966592390">"Koppel aan wi-fi voordat jy dit uitvee"</string>
    <string name="wifi_warning_dialog_text" msgid="6584060137703953174">"Dit maak dit makliker om jou e-SIM weer in die toekoms te gebruik sonder om jou diensverskaffer te kontak"</string>
    <string name="wifi_warning_continue_button" msgid="8171574741789688214">"Vee in elk geval uit"</string>
    <string name="wifi_warning_return_button" msgid="6226063181583906340">"OK"</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Koppel aan toestel"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"<xliff:g id="APPNAME">%1$s</xliff:g>-program wil \'n tydelike Wi‑Fi-netwerk gebruik om aan jou toestel te koppel"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Geen toestelle gekry nie. Maak seker dat toestelle aangeskakel is en beskikbaar is om te koppel."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Probeer weer"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Iets het voorgeval. Die program het die versoek gekanselleer om \'n toestel te kies."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Verbinding suksesvol"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Kon nie koppel nie"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Wys alles"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Soek tans na toestel …"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Koppel tans aan toestel …"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Links"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Regs"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Houer"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Instellingspaneel"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Dwangrekenaarmodus"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Verplig eksperimentele rekenaarmodus op sekondêre skerms"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Aktiveer nieveranderbare grootte in multivenster"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Laat programme met nieveranderbare grootte toe in multivenster"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Ignoreer gedwonge donkermodus"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Ignoreer die gedwonge donkermoduskenmerk om altyd aan te wees"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privaatheid"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Toestemmings, rekeningaktiwiteit, persoonlike data"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Kontroles"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Verwyder"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Hou"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Verwyder hierdie voorstel?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Daar is min bergingspasie oor. <xliff:g id="PERCENTAGE">%1$s</xliff:g> is gebruik – <xliff:g id="FREE_SPACE">%2$s</xliff:g> is beskikbaar"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Stuur terugvoer"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Wil jy vir ons terugvoer gee oor hierdie voorstel?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> is na knipbord gekopieer."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Toeganklikheidgebruik"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 app het volle toegang tot jou toestel}other{# apps het volle toegang tot jou toestel}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Belangrike inligting"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"GAAN VOORT"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NEE, DANKIE"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Ligging"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Jou diensverskaffer kan jou ligging bepaal wanneer jy hierdie diens vir noodoproepe gebruik.\n\nKry besonderhede op jou diensverskaffer se privaatheidsbeleid."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Jy kan toegang tot enige oorblywende tyd of data verloor. Vra jou verskaffer voordat jy dit verwyder."</string>
    <string name="content_capture" msgid="868372905432812238">"Programinhoud"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Stel programme in staat om inhoud na die Android-stelsel toe te stuur"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Vang stelselhoopstortings vas"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Geheuemerkinguitbreiding"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"Geheuemerkinguitbreiding (GMU) maak dit makliker om geheueveiligheidkwessies in jou app te kry, en maak toestelspesifieke kode daarin veiliger."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"As GMU aangeskakel word, kan dit veroorsaak dat toestel stadiger werk."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Kom meer te wete oor GMU"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Aktiveer GMU totdat jy dit afskakel"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Jy moet jou toestel herbegin om GMU aan te skakel."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Jy moet jou toestel herbegin om GMU af te skakel."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Aktiveer GMU vir een sessie"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Stelsel sal herbegin en eksperimentering met geheuemerkinguitbreiding (GMU) toelaat. GMU kan ’n negatiewe uitwerking op die stelsel se werkverrigting en stabiliteit hê. Sal met volgende herselflaai teruggestel word."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Herbegin vir een sessie terwyl GMU geaktiveer is"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"GMU is reeds geaktiveer"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Vasvangstelsel vir hoopstorting"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Kon nie stelselhoopstorting vasvang nie"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Vang outomaties stelselhoopstortings vas"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Vang outomaties \'n hoopstorting vir Android-stesel vas wanneer dit te veel gegeue gebruik"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Ontkoppel"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Noodoproepe"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Jou diensverskaffer steun nie noodoproepe oor Wi‑Fi nie.\nDie toestel skakel outomaties na \'n selnetwerk toe oor om \'n noodoproep te maak.\nNoodoproepe is net moontlik in gebiede met sellulêre dekking."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Gebruik Wi-Fi vir oproepe om gehalte te verbeter"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Inkomende MMS-boodskap"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Kan nie MMS-boodskap stuur nie"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Tik om MMS-boodskappe op <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> toe te laat wanneer mobiele data af is"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"MMS-boodskap"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Probleem met SIM-kombinasie"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Die gebruik van <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> kan funksionaliteit beperk. Tik om meer te wete te kom."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"SIM-kombinasie"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Jou werkbeleidinligting"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Instellings wat deur jou IT-admin bestuur word"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="enable_16k_pages" msgid="5009476566957520607">"Selflaai met 16K-bladsygrootte"</string>
    <string name="enable_16k_pages_summary" msgid="428117226069445198">"Selflaaitoestel wat 16K-bladsygrootte ondersteunde kern gebruik"</string>
    <string name="confirm_enable_16k_pages_title" msgid="6751570067857011642">"Herlaai met 16KB-bladsye versoenbare kern?"</string>
    <string name="confirm_enable_16k_pages_text" msgid="702888115148257215">"WAARSKUWING: Sommige apps is dalk nie versoenbaar met hierdie modus nie. Toestel sal ná bevestiging herlaai."</string>
    <string name="confirm_enable_4k_pages_title" msgid="626987400420355263">"Herlaai met 4KB-bladsye versoenbare kern?"</string>
    <string name="confirm_enable_4k_pages_text" msgid="6168921566226074524">"Toestel sal ná bevestiging herlaai."</string>
    <string name="toast_16k_update_failed_text" msgid="8888858987184345567">"Kon nie kern opdateer na 16KB-bladsy versoenbare kern nie."</string>
    <string name="progress_16k_ota_title" msgid="2117218313875523741">"Pas tans verandering toe"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Foutverslaghanteerder"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Bepaal watter program die Foutverslag-kortpad op jou toestel hanteer."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Persoonlik"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Werk"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Stelselverstek"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Geen"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Hierdie keuse is nie meer geldig nie. Probeer weer."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Druk en hou aan/af-skakelaar"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Druk en hou aan/af-skakelaar om toegang te kry"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Aan/af-kieslys"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Digitale assistent"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Kry toegang tot digitale assistent"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Kry toegang tot aan/af-kieslys"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Om dit te gebruik, moet jy eers \'n skermslot stel"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Aan/af-kieslys:\nDruk die aan/af-skakelaar en Volume Harder-knoppie gelyk"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Keer dat dit lui:\nDruk ’n volumeknoppie vir die kortpad"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Hoe lank om te druk en hou"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Verstel sensitiwiteit deur te kies hoe lank jy die aan/af-skakelaar moet druk en hou"</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">"Lank"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Wys beursie"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Gee toegang tot beursie van sluitskerm af"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Wys QR-kodeskandeerder"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Laat toegang tot QR-kodeskandeerder van sluitskerm af toe"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Wys toestelkontroles"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Van die sluitskerm af"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Gebruik toestelkontroles"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Skakel eers \"Wys toestelkontroles\" aan as jy wil gebruik"</string>
    <string name="lockscreen_double_line_clock_summary" msgid="4109235686687860393">"Horlosiegrootte verander na gelang van sluitskerminhoud"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Dinamiese horlosie"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Kortpaaie"</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">"Skakel VoLTE af?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Dit skakel ook jou 5G-verbinding af.\nJy kan nie die iternet tydens stemoproepe gebruik nie en sekere programme kan dalk nie werk nie."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Skort uitvoering van gekaste programme op"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Verval nooit nie."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"Huurtyd verval nooit nie."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Laat skermoorleggers op Instellings toe"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Laat programme wat oor ander programme kan wys toe om Instellings-skerms te oorlê"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Laat skynmodem toe"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Laat hierdie toestel toe om skymodemdiens vir instrumenttoetse te gebruik. Moenie dit tydens normale gebruik van die foon aktiveer nie"</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications" msgid="4987116103699222633">"Deaktiveer skermdelingbeskerming"</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications_summary" msgid="932295234626582052">"Deaktiveer stelseltoegepaste app- en kennisgewingsbeskerming tydens skermdeling"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Media"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Speld mediaspeler vas"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Mediaspeler bly oop in Kitsinstellings om terugspeel vinnig te hervat"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Wys media op sluitskerm"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Mediaspeler bly oop op sluitskerm om terugspeel vinnig te hervat"</string>
    <string name="media_controls_recommendations_title" msgid="3012692549413927608">"Wys media-aanbevelings vir Assistent"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Gegrond op jou aktiwiteit"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Versteek speler"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Wys speler"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"media"</string>
    <string name="camera_extensions_fallback_title" msgid="3604579046777004989">"Laat kamerasagteware-uitbreidings toe"</string>
    <string name="camera_extensions_fallback_description" msgid="6939818294458854536">"Aktiveer die versteksagteware-implementering van gevorderde kamera-eienskappe soos videografie vir swaksiendes."</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Bluetooth sal aanskakel"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM\'s"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Oproepe en SMS\'e"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Wi-fi-oproepe"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Maak en ontvang oproepe oor wi-fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Oproepe"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"voorkeur"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"word verkies vir oproepe"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"word verkies vir SMS\'e"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"nie beskikbaar nie"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Tydelik nie beskikbaar nie"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Geen SIM nie"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Netwerkvoorkeure"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"netwerkverbinding, internet, draadloos, data, wifi, wi-fi, wi fi, sellulêr, mobiel, selfoondiensverskaffer, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Stel jou internet terug?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Stel tans jou internet terug …"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Stel konnektiwiteit reg"</string>
    <string name="networks_available" msgid="3299512933684383474">"Netwerke beskikbaar"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Ontkoppel Ethernet om netwerke te wissel"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"W+-verbindings"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Maak dit vir Google Fi moontlik om W+-netwerke te gebruik om spoed en dekking te verbeter"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"W+-netwerk"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"e-SIM"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"e-SIM-kaarte"</string>
    <string name="sim_category_active_sim" msgid="3077009911935592178">"Aan"</string>
    <string name="sim_category_inactive_sim" msgid="7351553344148400450">"Af"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Verstek vir <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"oproepe"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"mobiele data"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Om toestelervaring te verbeter, kan programme en dienste steeds enige tyd na wi‑fi-netwerke soek, selfs wanneer wi‑fi af is. Dit kan byvoorbeeld gebruik word om ligginggegronde kenmerke en dienste te verbeter. Jy kan dit in Wi-fi-opsporinginstellings verander."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Verander"</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">"Gekoppel"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Tydelik gekoppel"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Gebruik <xliff:g id="SUBNAME">%1$s</xliff:g> tydelik"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Geen verbinding nie"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Mobiele data sal nie outomaties koppel nie"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Skakel mobiele data af?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Jy sal nie deur <xliff:g id="CARRIER">%s</xliff:g> toegang tot data of die internet hê nie. Internet sal net deur wi-fi beskikbaar wees."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"jou diensverskaffer"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Word nie deur jou organisasie toegelaat nie"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Nie beskikbaar nie omdat slaaptydmodus aan is"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Terugstelling van kennisgewingbelangrikheid is voltooi."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Programme"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"\'n Toestel wil toegang tot jou boodskappe hê. Tik vir besonderhede."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Gee toegang tot boodskappe?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"\'n Bluetooth-toestel, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, wil toegang tot jou boodskappe hê.\n\nJy het nog nooit aan <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> gekoppel nie."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"\'n Toestel wil toegang tot jou kontakte en oproeprekord hê. Tik vir besonderhede."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Gee toegang tot kontakte en oproeprekord?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"\'n Bluetooth-toestel, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, wil toegang tot jou kontakte en oproeprekord hê. Dit sluit data oor inkomende en uitgaande oproepe in.\n\nJy het nog nooit aan <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> gekoppel nie."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Helderheid"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Sluit skerm"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Voorkoms"</string>
    <string name="category_name_color" msgid="937514550918977151">"Kleur"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Ander skermkontroles"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Algemeen"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Gebruik Donkertema"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Gebruik Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Gebruik Verhoed Lui"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Gebruik Wi-Fi-warmkol"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Gebruik programvasspeld"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Gebruik ontwikkelaaropsies"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Gebruik drukdiens"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Laat veelvuldige gebruikers toe"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"laat toe, veelvuldig, gebruiker, baie"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Gebruik draadlose ontfouting"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Gebruik grafikadrywervoorkeure"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Gebruik Aandbeligting"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Gebruik NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Gebruik aanpasbare helderheid"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Gebruik Wi-Fi-oproepe"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Sien alle programme"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Slimaanstuur"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Slimaanstuur is geaktiveer"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Slimaanstuur is gedeaktiveer"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Oproepinstellings"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Dateer tans instellings op …"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Oproepinstellingsfout"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Netwerk- of SIM-fout."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"SIM is nie geaktiveer nie."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Voer foonnommers in"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Voer foonnommer in"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Foonnommer ontbreek."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"OK"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Laat 2G toe"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G is minder veilig, maar kan jou verbinding in sekere liggings verbeter. 2G word altyd toegelaat vir noodoproepe."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> vereis 2G om beskikbaar te wees"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Vereis enkripsie"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"Enkripsie is veiliger, maar jy sal dalk nie in sommige liggings kan koppel nie. Enkripsie word nooit vereis vir noodoproepe nie"</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Alle dienste"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Wys knipbordtoegang"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Wys \'n boodskap wanneer apps toegang het tot teks, prente of ander inhoud wat jy gekopieer het"</string>
    <string name="all_apps" msgid="3054120149509114789">"Alle apps"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Moenie toelaat nie"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultrawye band (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Help om die relatiewe posisie te bepaal van toestelle in die omtrek wat UWB het"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Skakel vliegtuigmodus af om UWB te gebruik"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB is nie in die huidige ligging beskikbaar nie"</string>
    <!-- no translation found for thread_network_settings_title (4212301030523859220) -->
    <skip />
    <!-- no translation found for thread_network_settings_summary (8065599651021748339) -->
    <skip />
    <!-- no translation found for thread_network_settings_summary_airplane_mode (7207252895832446979) -->
    <skip />
    <string name="camera_toggle_title" msgid="8952668677727244992">"Kameratoegang"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Mikrofoontoegang"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Vir apps en dienste"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Vir programme en dienste. As hierdie instelling af is, kan mikrofoondata steeds gedeel word wanneer jy \'n noodnommer bel."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Vorige"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Volgende"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Kleurvoorskou"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"SIM-toegangversoek"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"’n Toestel wil toegang tot jou SIM hê. Tik vir besonderhede."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Laat toegang tot SIM toe?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"’n Bluetooth-toestel, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, wil toegang tot data op jou SIM hê. Dit sluit jou kontakte in.\n\nTerwyl <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> gekoppel is, sal hulle alle oproepe ontvang wat na <xliff:g id="PHONE_NUMBER">%3$s</xliff:g> toe gemaak word."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Bluetooth-toestel is beskikbaar"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"\'n Toestel wil koppel. Tik vir besonderhede."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Koppel aan Bluetooth-toestel?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> wil aan hierdie foon koppel.\n\nJy het nog nie voorheen aan <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> gekoppel nie."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Moenie koppel nie"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Koppel"</string>
    <string name="tare_settings" msgid="3788654800004869077">"TARE-instellings"</string>
    <string name="tare_on" msgid="2386073225978684535">"Aan"</string>
    <string name="tare_off" msgid="6305694402929756726">"Af"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Stel terug na verstekinstellings"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Instellings is na verstek teruggestel."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Maksimum versadigingsbalans"</string>
    <string name="tare_balances" msgid="731881382594747961">"Saldo’s"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Verbruikslimiete"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Aanvanklike verbruikslimiet"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Minimum verbruikslimiet"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Maksimum verbruikslimiet"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Wysigers"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Handelinge (koste om te lewer)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Handelinge (basisprys)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Belonings per enkele geval"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Belonings per sekonde van geleentheidtydsduur"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Maksimum belonings per dag"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Programinstallering"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Topaktiwiteit"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Kennisgewing gesien"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Kennisgewing binne 15 minute gesien"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Kennisgewinginteraksie"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Legstukinteraksie"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Ander gebruikerinteraksie"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Begin maksimumprioriteittaak"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Maksimumprioriteittaak loop tans"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Begin hoëprioriteittaak"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Hoëprioriteittaak loop tans"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Begin verstekprioriteittaak"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Verstekprioriteittaak loop tans"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Begin laeprioriteittaak"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Laeprioriteittaak loop tans"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Begin minimumprioriteittaak"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Minimumprioriteittaak loop tans"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Taakuittelboete"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Minimum saldo as volgelaai (vrygestel)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Minimum saldo as volgelaai (hooflose stelselprogram)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Minimum saldo as volgelaai (orige programme)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Byvoeging vir minimum saldo as volgelaai (programopdateerders)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Laai tans"</item>
    <item msgid="658627268149681677">"Dut"</item>
    <item msgid="1599558140284643834">"Kragbesparingmodus"</item>
    <item msgid="588427840913221601">"Prosestoestand"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Bevestig"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Voorbeskou"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Kies \'n sluimerskerm"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Wys bykomende inligting"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Wys goed soos die tyd, weer of ander inligting op die sluimerskerm"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Wys huiskontroles"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Wys huiskontrolesknoppie op die sluimerskerm"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Nog instellings"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Kies jou sluimerskerm"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Kies wat jy op jou skerm sal sien wanneer jou tablet gedok is. Jou toestel kan meer energie gebruik wanneer ’n sluimerskerm gebruik word."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Pasmaak"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Pasmaak <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"\'n Herselflaai word vereis om vryevormsteun te aktiveer."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"\'n Herselflaai word vereis om rekenaarmodus vir sekondêre skerms te verplig."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Herselflaai nou"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Herselflaai later"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Ruimtelike Oudio"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"Oudio vanaf versoenbare media word meer meesleurend"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Kopnasporing"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"Oudio verander wanneer jy jou kop beweeg om natuurliker te klink"</string>
    <string name="bluetooth_details_permissions_sync_title" msgid="7277580382321003521">"Sinkroniseer toestemmings van foon af"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="8125037984381432059">"Gee jou horlosie dieselfde apptoestemmings as wat jy op hierdie foon toegelaat het"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Oudiotoesteltipe"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"Onbekend"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Luidspreker"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Oorfone"</string>
    <string name="bluetooth_details_audio_device_type_hearing_aid" msgid="1310631131071939859">"Gehoortoestel"</string>
    <string name="bluetooth_details_audio_device_type_carkit" msgid="4439017600454703229">"Motortoebehore"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Ander"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Netwerkaflaaikoerslimiet"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Stel netwerkbandwydte se binnedringingkoerslimiet op wat op alle netwerke wat \'n internetverbinding verskaf, toegepas word."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Stel netwerkaflaaikoerslimiet op"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Geen limiet nie"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Deaktiveer kindprosesbeperkings"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Deaktiveer beperkings op die stelselhulpbrongebruik van die app se kindprosesse"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Verplig aktivering van Notas-rol"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Aktiveer integrasie van stelsels om notas te maak met die Notas-rol. Doen niks as die Notas-rol reeds geaktiveer is nie. Vereis herselflaai."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Saai uit"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Saai <xliff:g id="CURRENTAPP">%1$s</xliff:g> uit"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Luister na uitsendings wat in jou omtrek speel"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Saai media na toestelle in jou omtrek uit, of luister na iemand anders se uitsending"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Uitsendings"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Luister tans na"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Soek uitsendings"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Verlaat uitsending"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Skandeer QR-kode"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Voer wagwoord in"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Kan nie koppel nie. Probeer weer."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Verkeerde wagwoord"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Kan nie by die uitsending aansluit nie"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Plaas die QR-kode hieronder in die middel om te begin luister"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"QR-kode is nie ’n geldige formaat nie"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Skakel om na e-SIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Dra e-SIM oor na ’n ander toestel"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# app}other{# apps}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Agtergrondgeïnstalleerde apps"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"Jou toestelvervaardiger kan apps op die agtergrond op jou toestel installeer, of jou diensverskaffer en ander vennote toelaat om dit te doen.\n\nEnige apps wat hier gelys word, word nie vir jou toestel se normale werking benodig nie. Jy kan apps wat jy nie wil hê nie, deïnstalleer."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Geen apps is op die agtergrond geïnstalleer nie"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Deïnstalleer app"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Apps wat in die afgelope # maand geïnstalleer is}other{Apps wat in die afgelope # maande geïnstalleer is}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Apps wat meer as # maand gelede geïnstalleer is}other{Apps wat meer as # maande gelede geïnstalleer is}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Aspekverhouding"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Probeer ’n nuwe aspekverhouding om hierdie app in te bekyk as dit nie ontwerp is om op jou <xliff:g id="DEVICE_NAME">%1$s</xliff:g> te pas nie"</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Probeer ’n nuwe aspekverhouding om hierdie app in te bekyk as dit nie ontwerp is om op jou <xliff:g id="DEVICE_NAME">%1$s</xliff:g> te pas nie. Sommige apps sal dalk nie vir sekere aspekverhoudings geoptimeer wees nie."</string>
    <string name="aspect_ratio_summary_text" msgid="4737461467467220325">"Probeer ’n nuwe aspekverhouding om ’n app in te bekyk as dit nie ontwerp is om op jou <xliff:g id="DEVICE_NAME">%1$s</xliff:g> te pas nie"</string>
    <string name="aspect_ratio_main_summary_text" msgid="5544816872094235840">"Probeer ’n nuwe aspekverhouding om ’n app in te bekyk as dit nie ontwerp is om op jou <xliff:g id="DEVICE_NAME">%1$s</xliff:g> te pas nie. Sommige apps sal dalk nie vir sekere aspekverhoudings geoptimeer wees nie."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Voorgestelde apps"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Veranderde apps"</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"Appverstek"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Volskerm"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Halfskerm"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Toestelaspekverhouding"</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> tot <xliff:g id="DENOMINATOR">%2$s</xliff:g>"</string>
    <string name="app_aspect_ratio_footer" msgid="4029509301182067475">"Die app sal herbegin as jy die aspekverhouding verander. Jy kan ongestoorde veranderinge verloor. Sommige apps sal dalk nie vir sekere aspekverhoudings geoptimeer wees nie."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Aspekverhouding (eksperimenteel)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Aspekverhouding (eksperiment)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Aspekverhouding (Labs)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"Eksperimenteel"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Eksperiment"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Labs"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Vingerafdruksensor"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Flitskennisgewings"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Meer oor flitskennisgewings"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Af"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Aan/kameraflits"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Aan/skermflits"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Aan / kamera- en skermflits"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Flits die kameralig of die skerm wanneer jy kennisgewings ontvang of wanneer wekkers lui"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Flits die skerm wanneer jy kennisgewings ontvang of wanneer wekkers lui"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Gebruik flitskennisgewings versigtig as jy ligsensitief is"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"flits, lig, hardhorend, gehoorverlies"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Voorskou"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Kameraflits"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Skermflits"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Skermflitskleur"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Blou"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Hemelblou"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Siaan"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Lentegroen"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Groen"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Chartreusegroen"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Geel"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Oranje"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Rooi"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Roos"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Magenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Pers"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Klaar"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Kanselleer"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Kontras"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Standaard"</string>
    <!-- no translation found for contrast_default (8918545965525226966) -->
    <skip />
    <string name="contrast_medium" msgid="384414510709285811">"Medium"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Hoog"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Hierdie app kan net in 1 venster oopgemaak word"</string>
    <string name="generic_accessibility_service_on" msgid="4466229372357726824">"Aan"</string>
    <string name="generic_accessibility_service_off" msgid="4759859497651675724">"Af"</string>
    <string name="generic_accessibility_feature_shortcut_off" msgid="4022872394514077907">"Af"</string>
    <string name="accessibility_shortcut_state_off" msgid="8158137799007601475">"Af"</string>
    <string name="daltonizer_state_on" msgid="131013270022603983">"Aan"</string>
    <string name="daltonizer_state_off" msgid="1162285688069856179">"Af"</string>
    <string name="color_inversion_state_on" msgid="1160969033636440368">"Aan"</string>
    <string name="color_inversion_state_off" msgid="6925638668080451724">"Af"</string>
    <string name="color_inversion_feature_summary" msgid="1199876648549627647">"Maak ligte skerms donker en donker skerms lig"</string>
    <string name="magnification_feature_summary" msgid="2053971569640663564">"Zoem in op die skerm"</string>
    <string name="autoclick_disabled" msgid="3213396804955002120">"Af"</string>
    <string name="show_captions_disabled" msgid="690650956523818755">"Af"</string>
    <string name="show_captions_enabled" msgid="7089043007924626">"Aan"</string>
    <string name="live_caption_disabled" msgid="3562035026547887366">"Af"</string>
    <string name="live_caption_enabled" msgid="5269360946200718949">"Aan"</string>
    <string name="about_phone_device_name_warning" msgid="3243226572404472381">"Jou toestelnaam is sigbaar vir apps wat jy geïnstalleer het. Ander mense sal dit dalk ook kan sien as jy aan Bluetooth-toestelle koppel, aan ’n wi-fi-netwerk koppel, of ’n wi-fi-warmkol opstel."</string>
    <string name="grammatical_gender_title" msgid="8584242850477270828">"Grammatikale geslag"</string>
    <string name="grammatical_gender_dialog_title" msgid="8754048592099871587">"Kies grammatikale geslag"</string>
    <string name="content_protection_preference_title" msgid="5069260032659193074">"Skandeer vir misleidende apps"</string>
    <string name="content_protection_preference_summary" msgid="2252393849408445391">"Gaan appaktiwiteit na vir uitvissing"</string>
    <string name="content_protection_preference_user_consent_switch_title" msgid="1797782616799594426">"Gebruik skandering vir misleidende apps"</string>
    <string name="content_protection_preference_user_consent_work_profile_switch_title" msgid="3004347470520916069">"Gebruik skandering vir misleidende werkapps"</string>
    <string name="content_protection_preference_subpage_summary" msgid="3595621220981703364"></string>
    <string name="content_protection_preference_subpage_info" msgid="6890886357653365489"></string>
    <string name="accessibility_setup_password_complete" msgid="6358749253318369077">"Wagwoord is nou opgestel"</string>
    <string name="show_stylus_pointer_icon" msgid="1010583689203665786">"Wys wyser terwyl daar gehou word"</string>
</resources>
